mirror of
https://github.com/RetroShare/RetroShare.git
synced 2025-05-02 14:16:16 -04:00
FeedReader plugin:
- added new classes for XML/HTML parse and modify - added basic error handling - added new GUI for a preview and a tree to show the structure of the page (will be continued) git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-gxs-b1@5412 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
thunder2
parent
acaefada65
commit
f51af0d4de
24 changed files with 1959 additions and 509 deletions
|
|
@ -38,10 +38,12 @@ RsFeedReader *rsFeedReader = NULL;
|
|||
|
||||
p3FeedReader::p3FeedReader(RsPluginHandler* pgHandler)
|
||||
: RsPQIService(RS_PKT_TYPE_FEEDREADER_CONFIG, CONFIG_TYPE_FEEDREADER, 5, pgHandler),
|
||||
mFeedReaderMtx("p3FeedReader"), mDownloadMutex("p3FeedReaderDownload"), mProcessMutex("p3FeedReaderProcess")
|
||||
mFeedReaderMtx("p3FeedReader"), mDownloadMutex("p3FeedReaderDownload"), mProcessMutex("p3FeedReaderProcess"), mPreviewMutex("p3FeedReaderPreview")
|
||||
{
|
||||
mNextFeedId = 1;
|
||||
mNextMsgId = 1;
|
||||
mNextPreviewFeedId = -1; // use negative values
|
||||
mNextPreviewMsgId = -1; // use negative values
|
||||
mStandardUpdateInterval = 60 * 60; // 60 minutes
|
||||
mStandardStorageTime = 30 * 60 * 60 * 24; // 30 days
|
||||
mStandardUseProxy = false;
|
||||
|
|
@ -49,13 +51,16 @@ p3FeedReader::p3FeedReader(RsPluginHandler* pgHandler)
|
|||
mLastClean = 0;
|
||||
mNotify = NULL;
|
||||
|
||||
mPreviewDownloadThread = NULL;
|
||||
mPreviewProcessThread = NULL;
|
||||
|
||||
/* start download thread */
|
||||
p3FeedReaderThread *frt = new p3FeedReaderThread(this, p3FeedReaderThread::DOWNLOAD);
|
||||
p3FeedReaderThread *frt = new p3FeedReaderThread(this, p3FeedReaderThread::DOWNLOAD, "");
|
||||
mThreads.push_back(frt);
|
||||
frt->start();
|
||||
|
||||
/* start process thread */
|
||||
frt = new p3FeedReaderThread(this, p3FeedReaderThread::PROCESS);
|
||||
frt = new p3FeedReaderThread(this, p3FeedReaderThread::PROCESS, "");
|
||||
mThreads.push_back(frt);
|
||||
frt->start();
|
||||
}
|
||||
|
|
@ -80,7 +85,7 @@ static void feedToInfo(const RsFeedReaderFeed *feed, FeedInfo &info)
|
|||
info.lastUpdate = feed->lastUpdate;
|
||||
info.forumId = feed->forumId;
|
||||
info.storageTime = feed->storageTime;
|
||||
info.error = (feed->errorState != RS_FEED_ERRORSTATE_OK); // currently only as bool
|
||||
info.errorState = feed->errorState;
|
||||
info.errorString = feed->errorString;
|
||||
|
||||
info.flag.folder = (feed->flag & RS_FEED_FLAG_FOLDER);
|
||||
|
|
@ -95,6 +100,8 @@ static void feedToInfo(const RsFeedReaderFeed *feed, FeedInfo &info)
|
|||
info.flag.embedImages = (feed->flag & RS_FEED_FLAG_EMBED_IMAGES);
|
||||
info.flag.saveCompletePage = (feed->flag & RS_FEED_FLAG_SAVE_COMPLETE_PAGE);
|
||||
|
||||
info.flag.preview = feed->preview;
|
||||
|
||||
switch (feed->workstate) {
|
||||
case RsFeedReaderFeed::WAITING:
|
||||
info.workstate = FeedInfo::WAITING;
|
||||
|
|
@ -134,6 +141,8 @@ static void infoToFeed(const FeedInfo &info, RsFeedReaderFeed *feed, bool add)
|
|||
feed->forumId = info.forumId;
|
||||
}
|
||||
|
||||
// feed->preview = info.flag.preview;
|
||||
|
||||
uint32_t oldFlag = feed->flag;
|
||||
feed->flag = 0;
|
||||
if (info.flag.infoFromFeed) {
|
||||
|
|
@ -199,12 +208,14 @@ void p3FeedReader::setNotify(RsFeedReaderNotify *notify)
|
|||
uint32_t p3FeedReader::getStandardStorageTime()
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
return mStandardStorageTime;
|
||||
}
|
||||
|
||||
void p3FeedReader::setStandardStorageTime(uint32_t storageTime)
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
if (mStandardStorageTime != storageTime) {
|
||||
mStandardStorageTime = storageTime;
|
||||
IndicateConfigChanged();
|
||||
|
|
@ -214,12 +225,14 @@ void p3FeedReader::setStandardStorageTime(uint32_t storageTime)
|
|||
uint32_t p3FeedReader::getStandardUpdateInterval()
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
return mStandardUpdateInterval;
|
||||
}
|
||||
|
||||
void p3FeedReader::setStandardUpdateInterval(uint32_t updateInterval)
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
if (mStandardUpdateInterval != updateInterval) {
|
||||
mStandardUpdateInterval = updateInterval;
|
||||
IndicateConfigChanged();
|
||||
|
|
@ -229,14 +242,17 @@ void p3FeedReader::setStandardUpdateInterval(uint32_t updateInterval)
|
|||
bool p3FeedReader::getStandardProxy(std::string &proxyAddress, uint16_t &proxyPort)
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
proxyAddress = mStandardProxyAddress;
|
||||
proxyPort = mStandardProxyPort;
|
||||
|
||||
return mStandardUseProxy;
|
||||
}
|
||||
|
||||
void p3FeedReader::setStandardProxy(bool useProxy, const std::string &proxyAddress, uint16_t proxyPort)
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
if (useProxy != mStandardUseProxy || proxyAddress != mStandardProxyAddress || proxyPort != mStandardProxyPort) {
|
||||
mStandardProxyAddress = proxyAddress;
|
||||
mStandardProxyPort = proxyPort;
|
||||
|
|
@ -247,12 +263,37 @@ void p3FeedReader::setStandardProxy(bool useProxy, const std::string &proxyAddre
|
|||
|
||||
void p3FeedReader::stop()
|
||||
{
|
||||
/* stop threads */
|
||||
std::list<p3FeedReaderThread*>::iterator it;
|
||||
for (it = mThreads.begin(); it != mThreads.end(); ++it) {
|
||||
(*it)->join();
|
||||
{
|
||||
RsStackMutex stack(mPreviewMutex); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
stopPreviewThreads_locked();
|
||||
}
|
||||
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
/* stop threads */
|
||||
std::list<p3FeedReaderThread*>::iterator it;
|
||||
for (it = mThreads.begin(); it != mThreads.end(); ++it) {
|
||||
(*it)->join();
|
||||
delete(*it);
|
||||
}
|
||||
mThreads.clear();
|
||||
}
|
||||
}
|
||||
|
||||
void p3FeedReader::stopPreviewThreads_locked()
|
||||
{
|
||||
if (mPreviewDownloadThread) {
|
||||
mPreviewDownloadThread->join();
|
||||
delete mPreviewDownloadThread;
|
||||
mPreviewDownloadThread = NULL;
|
||||
}
|
||||
if (mPreviewProcessThread) {
|
||||
mPreviewProcessThread->join();
|
||||
delete mPreviewProcessThread;
|
||||
mPreviewProcessThread = NULL;
|
||||
}
|
||||
mThreads.clear();
|
||||
}
|
||||
|
||||
RsFeedAddResult p3FeedReader::addFolder(const std::string parentId, const std::string &name, std::string &feedId)
|
||||
|
|
@ -481,6 +522,8 @@ void p3FeedReader::deleteAllMsgs_locked(RsFeedReaderFeed *fi)
|
|||
bool p3FeedReader::removeFeed(const std::string &feedId)
|
||||
{
|
||||
std::list<std::string> removedFeedIds;
|
||||
bool changed = false;
|
||||
bool preview = false;
|
||||
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
|
@ -497,6 +540,8 @@ bool p3FeedReader::removeFeed(const std::string &feedId)
|
|||
|
||||
RsFeedReaderFeed *fi = feedIt->second;
|
||||
mFeeds.erase(feedIt);
|
||||
changed = !fi->preview;
|
||||
preview = fi->preview;
|
||||
|
||||
if (fi->flag & RS_FEED_FLAG_FOLDER) {
|
||||
std::list<std::string> feedIds;
|
||||
|
|
@ -534,7 +579,18 @@ bool p3FeedReader::removeFeed(const std::string &feedId)
|
|||
delete(fi);
|
||||
}
|
||||
|
||||
IndicateConfigChanged();
|
||||
if (changed) {
|
||||
IndicateConfigChanged();
|
||||
}
|
||||
|
||||
if (preview) {
|
||||
RsStackMutex stack(mPreviewMutex); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
/* only check download thread */
|
||||
if (mPreviewDownloadThread && mPreviewDownloadThread->getFeedId() == feedId) {
|
||||
stopPreviewThreads_locked();
|
||||
}
|
||||
}
|
||||
|
||||
if (mNotify) {
|
||||
/* only notify remove of feed */
|
||||
|
|
@ -547,6 +603,63 @@ bool p3FeedReader::removeFeed(const std::string &feedId)
|
|||
return true;
|
||||
}
|
||||
|
||||
bool p3FeedReader::addPreviewFeed(const FeedInfo &feedInfo, std::string &feedId)
|
||||
{
|
||||
{
|
||||
RsStackMutex stack(mPreviewMutex); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
stopPreviewThreads_locked();
|
||||
}
|
||||
|
||||
feedId.clear();
|
||||
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::addPreviewFeed - add feed " << feedInfo.name << ", url " << feedInfo.url << std::endl;
|
||||
#endif
|
||||
|
||||
RsFeedReaderFeed *fi = new RsFeedReaderFeed;
|
||||
infoToFeed(feedInfo, fi, true);
|
||||
rs_sprintf(fi->feedId, "preview%d", mNextPreviewFeedId--);
|
||||
fi->preview = true;
|
||||
|
||||
/* process feed */
|
||||
fi->workstate = RsFeedReaderFeed::WAITING_TO_DOWNLOAD;
|
||||
fi->content.clear();
|
||||
|
||||
/* clear not needed members */
|
||||
fi->parentId.clear();
|
||||
fi->updateInterval = 0;
|
||||
fi->lastUpdate = 0;
|
||||
fi->forumId.clear();
|
||||
fi->storageTime = 0;
|
||||
|
||||
mFeeds[fi->feedId] = fi;
|
||||
|
||||
feedId = fi->feedId;
|
||||
}
|
||||
|
||||
if (mNotify) {
|
||||
mNotify->feedChanged(feedId, NOTIFY_TYPE_ADD);
|
||||
}
|
||||
|
||||
{
|
||||
RsStackMutex stack(mPreviewMutex); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
/* start download thread for preview */
|
||||
mPreviewDownloadThread = new p3FeedReaderThread(this, p3FeedReaderThread::DOWNLOAD, feedId);
|
||||
mPreviewDownloadThread->start();
|
||||
|
||||
/* start process thread for preview */
|
||||
mPreviewProcessThread = new p3FeedReaderThread(this, p3FeedReaderThread::PROCESS, feedId);
|
||||
mPreviewProcessThread->start();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void p3FeedReader::getFeedList(const std::string &parentId, std::list<FeedInfo> &feedInfos)
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
|
@ -555,6 +668,10 @@ void p3FeedReader::getFeedList(const std::string &parentId, std::list<FeedInfo>
|
|||
for (feedIt = mFeeds.begin(); feedIt != mFeeds.end(); ++feedIt) {
|
||||
RsFeedReaderFeed *fi = feedIt->second;
|
||||
|
||||
if (fi->preview) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (fi->parentId == parentId) {
|
||||
FeedInfo feedInfo;
|
||||
feedToInfo(fi, feedInfo);
|
||||
|
|
@ -610,6 +727,8 @@ bool p3FeedReader::getMsgInfo(const std::string &feedId, const std::string &msgI
|
|||
|
||||
bool p3FeedReader::removeMsg(const std::string &feedId, const std::string &msgId)
|
||||
{
|
||||
bool changed = false;
|
||||
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
|
|
@ -622,6 +741,7 @@ bool p3FeedReader::removeMsg(const std::string &feedId, const std::string &msgId
|
|||
}
|
||||
|
||||
RsFeedReaderFeed *fi = feedIt->second;
|
||||
changed = !fi->preview;
|
||||
|
||||
std::map<std::string, RsFeedReaderMsg*>::iterator msgIt;
|
||||
msgIt = fi->mMsgs.find(msgId);
|
||||
|
|
@ -635,7 +755,10 @@ bool p3FeedReader::removeMsg(const std::string &feedId, const std::string &msgId
|
|||
msgIt->second->flag |= RS_FEEDMSG_FLAG_DELETED;
|
||||
}
|
||||
|
||||
IndicateConfigChanged();
|
||||
if (changed) {
|
||||
IndicateConfigChanged();
|
||||
}
|
||||
|
||||
if (mNotify) {
|
||||
mNotify->feedChanged(feedId, NOTIFY_TYPE_MOD);
|
||||
mNotify->msgChanged(feedId, msgId, NOTIFY_TYPE_DEL);
|
||||
|
|
@ -647,6 +770,7 @@ bool p3FeedReader::removeMsg(const std::string &feedId, const std::string &msgId
|
|||
bool p3FeedReader::removeMsgs(const std::string &feedId, const std::list<std::string> &msgIds)
|
||||
{
|
||||
std::list<std::string> removedMsgs;
|
||||
bool changed = false;
|
||||
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
|
@ -660,6 +784,7 @@ bool p3FeedReader::removeMsgs(const std::string &feedId, const std::list<std::st
|
|||
}
|
||||
|
||||
RsFeedReaderFeed *fi = feedIt->second;
|
||||
changed = !fi->preview;
|
||||
|
||||
std::list<std::string>::const_iterator idIt;
|
||||
for (idIt = msgIds.begin(); idIt != msgIds.end(); ++idIt) {
|
||||
|
|
@ -678,6 +803,10 @@ bool p3FeedReader::removeMsgs(const std::string &feedId, const std::list<std::st
|
|||
}
|
||||
}
|
||||
|
||||
if (changed) {
|
||||
IndicateConfigChanged();
|
||||
}
|
||||
|
||||
if (mNotify && !removedMsgs.empty()) {
|
||||
mNotify->feedChanged(feedId, NOTIFY_TYPE_MOD);
|
||||
|
||||
|
|
@ -758,8 +887,41 @@ bool p3FeedReader::getFeedMsgList(const std::string &feedId, std::list<FeedMsgIn
|
|||
return true;
|
||||
}
|
||||
|
||||
bool p3FeedReader::getFeedMsgIdList(const std::string &feedId, std::list<std::string> &msgIds)
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
std::map<std::string, RsFeedReaderFeed*>::iterator feedIt = mFeeds.find(feedId);
|
||||
if (feedIt == mFeeds.end()) {
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::getFeedMsgList - feed " << feedId << " not found" << std::endl;
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
RsFeedReaderFeed *fi = feedIt->second;
|
||||
|
||||
std::map<std::string, RsFeedReaderMsg*>::iterator msgIt;
|
||||
for (msgIt = fi->mMsgs.begin(); msgIt != fi->mMsgs.end(); ++msgIt) {
|
||||
RsFeedReaderMsg *mi = msgIt->second;
|
||||
|
||||
if (mi->flag & RS_FEEDMSG_FLAG_DELETED) {
|
||||
continue;
|
||||
}
|
||||
|
||||
msgIds.push_back(mi->msgId);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool canProcessFeed(RsFeedReaderFeed *fi)
|
||||
{
|
||||
if (fi->preview) {
|
||||
/* preview feed */
|
||||
return false;
|
||||
}
|
||||
|
||||
if (fi->flag & RS_FEED_FLAG_DEACTIVATED) {
|
||||
/* deactivated */
|
||||
return false;
|
||||
|
|
@ -939,6 +1101,7 @@ int p3FeedReader::tick()
|
|||
/* clean feeds */
|
||||
cleanFeeds();
|
||||
|
||||
/* check feeds for update interval */
|
||||
time_t currentTime = time(NULL);
|
||||
std::list<std::string> feedToDownload;
|
||||
std::map<std::string, RsFeedReaderFeed*>::iterator feedIt;
|
||||
|
|
@ -1105,6 +1268,9 @@ bool p3FeedReader::saveList(bool &cleanup, std::list<RsItem *> & saveData)
|
|||
std::map<std::string, RsFeedReaderFeed *>::iterator it1;
|
||||
for (it1 = mFeeds.begin(); it1 != mFeeds.end(); ++it1) {
|
||||
RsFeedReaderFeed *fi = it1->second;
|
||||
if (fi->preview) {
|
||||
continue;
|
||||
}
|
||||
saveData.push_back(fi);
|
||||
|
||||
std::map<std::string, RsFeedReaderMsg*>::iterator it2;
|
||||
|
|
@ -1227,11 +1393,11 @@ bool p3FeedReader::loadList(std::list<RsItem *>& load)
|
|||
/****************************** internal ***********************************/
|
||||
/***************************************************************************/
|
||||
|
||||
bool p3FeedReader::getFeedToDownload(RsFeedReaderFeed &feed)
|
||||
bool p3FeedReader::getFeedToDownload(RsFeedReaderFeed &feed, const std::string &neededFeedId)
|
||||
{
|
||||
std::string feedId;
|
||||
std::string feedId = neededFeedId;
|
||||
|
||||
{
|
||||
if (feedId.empty()) {
|
||||
RsStackMutex stack(mDownloadMutex); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
if (mDownloadFeeds.empty()) {
|
||||
|
|
@ -1257,6 +1423,7 @@ bool p3FeedReader::getFeedToDownload(RsFeedReaderFeed &feed)
|
|||
return false;
|
||||
}
|
||||
|
||||
/* check state */
|
||||
if (it->second->workstate != RsFeedReaderFeed::WAITING_TO_DOWNLOAD) {
|
||||
std::cerr << "p3FeedReader::getFeedToDownload - feed in wrong work state for download " << it->second->workstate << std::endl;
|
||||
return false;
|
||||
|
|
@ -1282,6 +1449,8 @@ bool p3FeedReader::getFeedToDownload(RsFeedReaderFeed &feed)
|
|||
|
||||
void p3FeedReader::onDownloadSuccess(const std::string &feedId, const std::string &content, std::string &icon)
|
||||
{
|
||||
bool preview;
|
||||
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
|
|
@ -1298,11 +1467,14 @@ void p3FeedReader::onDownloadSuccess(const std::string &feedId, const std::strin
|
|||
RsFeedReaderFeed *fi = it->second;
|
||||
fi->workstate = RsFeedReaderFeed::WAITING_TO_PROCESS;
|
||||
fi->content = content;
|
||||
preview = fi->preview;
|
||||
|
||||
if (fi->icon != icon) {
|
||||
fi->icon = icon;
|
||||
|
||||
IndicateConfigChanged();
|
||||
if (!preview) {
|
||||
IndicateConfigChanged();
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
|
|
@ -1310,7 +1482,7 @@ void p3FeedReader::onDownloadSuccess(const std::string &feedId, const std::strin
|
|||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
if (!preview) {
|
||||
RsStackMutex stack(mProcessMutex); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
if (std::find(mProcessFeeds.begin(), mProcessFeeds.end(), feedId) == mProcessFeeds.end()) {
|
||||
|
|
@ -1324,7 +1496,7 @@ void p3FeedReader::onDownloadSuccess(const std::string &feedId, const std::strin
|
|||
}
|
||||
}
|
||||
|
||||
void p3FeedReader::onDownloadError(const std::string &feedId, p3FeedReaderThread::DownloadResult result, const std::string &error)
|
||||
void p3FeedReader::onDownloadError(const std::string &feedId, p3FeedReaderThread::DownloadResult result, const std::string &errorString)
|
||||
{
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
|
@ -1344,7 +1516,6 @@ void p3FeedReader::onDownloadError(const std::string &feedId, p3FeedReaderThread
|
|||
fi->lastUpdate = time(NULL);
|
||||
fi->content.clear();
|
||||
|
||||
long todo; // sort error codes
|
||||
switch (result) {
|
||||
case p3FeedReaderThread::DOWNLOAD_SUCCESS:
|
||||
/* this should not happen */
|
||||
|
|
@ -1354,9 +1525,6 @@ void p3FeedReader::onDownloadError(const std::string &feedId, p3FeedReaderThread
|
|||
case p3FeedReaderThread::DOWNLOAD_ERROR:
|
||||
fi->errorState = RS_FEED_ERRORSTATE_DOWNLOAD_ERROR;
|
||||
break;
|
||||
case p3FeedReaderThread::DOWNLOAD_INTERNAL_ERROR:
|
||||
fi->errorState = RS_FEED_ERRORSTATE_DOWNLOAD_INTERNAL_ERROR;
|
||||
break;
|
||||
case p3FeedReaderThread::DOWNLOAD_UNKNOWN_CONTENT_TYPE:
|
||||
fi->errorState = RS_FEED_ERRORSTATE_DOWNLOAD_UNKNOWN_CONTENT_TYPE;
|
||||
break;
|
||||
|
|
@ -1370,13 +1538,15 @@ void p3FeedReader::onDownloadError(const std::string &feedId, p3FeedReaderThread
|
|||
fi->errorState = RS_FEED_ERRORSTATE_DOWNLOAD_INTERNAL_ERROR;
|
||||
}
|
||||
|
||||
fi->errorString = error;
|
||||
fi->errorString = errorString;
|
||||
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::onDownloadError - feed " << fi->feedId << " (" << fi->name << ") error download, result = " << result << ", errorState = " << fi->errorState << ", error = " << error << std::endl;
|
||||
std::cerr << "p3FeedReader::onDownloadError - feed " << fi->feedId << " (" << fi->name << ") error download, result = " << result << ", errorState = " << fi->errorState << ", error = " << errorString << std::endl;
|
||||
#endif
|
||||
|
||||
IndicateConfigChanged();
|
||||
if (!fi->preview) {
|
||||
IndicateConfigChanged();
|
||||
}
|
||||
}
|
||||
|
||||
if (mNotify) {
|
||||
|
|
@ -1384,11 +1554,11 @@ void p3FeedReader::onDownloadError(const std::string &feedId, p3FeedReaderThread
|
|||
}
|
||||
}
|
||||
|
||||
bool p3FeedReader::getFeedToProcess(RsFeedReaderFeed &feed)
|
||||
bool p3FeedReader::getFeedToProcess(RsFeedReaderFeed &feed, const std::string &neededFeedId)
|
||||
{
|
||||
std::string feedId;
|
||||
std::string feedId = neededFeedId;
|
||||
|
||||
{
|
||||
if (feedId.empty()) {
|
||||
RsStackMutex stack(mProcessMutex); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
if (mProcessFeeds.empty()) {
|
||||
|
|
@ -1414,13 +1584,13 @@ bool p3FeedReader::getFeedToProcess(RsFeedReaderFeed &feed)
|
|||
return false;
|
||||
}
|
||||
|
||||
if (it->second->workstate != RsFeedReaderFeed::WAITING_TO_PROCESS) {
|
||||
std::cerr << "p3FeedReader::getFeedToProcess - feed in wrong state for process " << it->second->workstate << std::endl;
|
||||
RsFeedReaderFeed *fi = it->second;
|
||||
|
||||
if (fi->workstate != RsFeedReaderFeed::WAITING_TO_PROCESS) {
|
||||
std::cerr << "p3FeedReader::getFeedToProcess - feed in wrong state for process " << fi->workstate << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
RsFeedReaderFeed *fi = it->second;
|
||||
|
||||
/* set state to processing */
|
||||
fi->workstate = RsFeedReaderFeed::PROCESSING;
|
||||
fi->errorState = RS_FEED_ERRORSTATE_OK;
|
||||
|
|
@ -1430,7 +1600,7 @@ bool p3FeedReader::getFeedToProcess(RsFeedReaderFeed &feed)
|
|||
feed = *fi;
|
||||
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::getFeedToProcess - feed " << it->second->feedId << " (" << it->second->name << ") is starting to process" << std::endl;
|
||||
std::cerr << "p3FeedReader::getFeedToProcess - feed " << fi->feedId << " (" << fi->name << ") is starting to process" << std::endl;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -1447,8 +1617,6 @@ bool p3FeedReader::onProcessSuccess_filterMsg(const std::string &feedId, std::li
|
|||
std::cerr << "p3FeedReader::onProcessSuccess_filterMsg - feed " << feedId << " got " << msgs.size() << " messages" << std::endl;
|
||||
#endif
|
||||
|
||||
bool result = true;
|
||||
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
|
|
@ -1463,10 +1631,67 @@ bool p3FeedReader::onProcessSuccess_filterMsg(const std::string &feedId, std::li
|
|||
}
|
||||
|
||||
RsFeedReaderFeed *fi = it->second;
|
||||
bool forum = (fi->flag & RS_FEED_FLAG_FORUM);
|
||||
uint32_t errorState = RS_FEED_ERRORSTATE_OK;
|
||||
|
||||
if (forum) {
|
||||
std::list<RsFeedReaderMsg*>::iterator newMsgIt;
|
||||
for (newMsgIt = msgs.begin(); newMsgIt != msgs.end(); ) {
|
||||
RsFeedReaderMsg *miNew = *newMsgIt;
|
||||
/* search for existing msg */
|
||||
std::map<std::string, RsFeedReaderMsg*>::iterator msgIt;
|
||||
for (msgIt = fi->mMsgs.begin(); msgIt != fi->mMsgs.end(); ++msgIt) {
|
||||
RsFeedReaderMsg *mi = msgIt->second;
|
||||
if (mi->title == miNew->title && mi->link == miNew->link && mi->author == miNew->author) {
|
||||
/* msg exist */
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (msgIt != fi->mMsgs.end()) {
|
||||
/* msg exists */
|
||||
delete(miNew);
|
||||
newMsgIt = msgs.erase(newMsgIt);
|
||||
} else {
|
||||
++newMsgIt;
|
||||
}
|
||||
}
|
||||
|
||||
fi->content.clear();
|
||||
fi->errorString.clear();
|
||||
|
||||
if (!fi->preview) {
|
||||
IndicateConfigChanged();
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void p3FeedReader::onProcessSuccess_addMsgs(const std::string &feedId, bool result, std::list<RsFeedReaderMsg*> &msgs, bool single)
|
||||
{
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_addMsgs - feed " << feedId << " got " << msgs.size() << " messages" << std::endl;
|
||||
#endif
|
||||
|
||||
std::list<std::string> addedMsgs;
|
||||
std::string forumId;
|
||||
std::list<RsFeedReaderMsg> forumMsgs;
|
||||
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
/* find feed */
|
||||
std::map<std::string, RsFeedReaderFeed*>::iterator it = mFeeds.find(feedId);
|
||||
if (it == mFeeds.end()) {
|
||||
/* feed not found */
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_addMsgs - feed " << feedId << " not found" << std::endl;
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
RsFeedReaderFeed *fi = it->second;
|
||||
bool forum = (fi->flag & RS_FEED_FLAG_FORUM) && !fi->preview;
|
||||
RsFeedReaderErrorState errorState = RS_FEED_ERRORSTATE_OK;
|
||||
|
||||
if (result && forum && !msgs.empty()) {
|
||||
if (fi->forumId.empty()) {
|
||||
/* create new forum */
|
||||
std::wstring forumName;
|
||||
|
|
@ -1491,14 +1716,15 @@ bool p3FeedReader::onProcessSuccess_filterMsg(const std::string &feedId, std::li
|
|||
librs::util::ConvertUtf8ToUtf16(fi->description, forumDescription);
|
||||
/* create anonymous public forum */
|
||||
fi->forumId = rsForums->createForum(forumName, forumDescription, RS_DISTRIB_PUBLIC | RS_DISTRIB_AUTHEN_ANON);
|
||||
forumId = fi->forumId;
|
||||
|
||||
if (fi->forumId.empty()) {
|
||||
errorState = RS_FEED_ERRORSTATE_FORUM_CREATE;
|
||||
errorState = RS_FEED_ERRORSTATE_PROCESS_FORUM_CREATE;
|
||||
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_filterMsg - can't create forum for feed " << feedId << " (" << it->second->name << ") - ignore all messages" << std::endl;
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_filterMsg - can't create forum for feed " << feedId << " (" << fi->name << ") - ignore all messages" << std::endl;
|
||||
} else {
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_filterMsg - forum " << forumId << " (" << fi->name << ") created" << std::endl;
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_filterMsg - forum " << fi->forumId << " (" << fi->name << ") created" << std::endl;
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
|
|
@ -1506,129 +1732,66 @@ bool p3FeedReader::onProcessSuccess_filterMsg(const std::string &feedId, std::li
|
|||
ForumInfo forumInfo;
|
||||
if (rsForums->getForumInfo(fi->forumId, forumInfo)) {
|
||||
if ((forumInfo.subscribeFlags & RS_DISTRIB_ADMIN) == 0) {
|
||||
errorState = RS_FEED_ERRORSTATE_FORUM_NO_ADMIN;
|
||||
errorState = RS_FEED_ERRORSTATE_PROCESS_FORUM_NO_ADMIN;
|
||||
} else if ((forumInfo.forumFlags & RS_DISTRIB_AUTHEN_REQ) || (forumInfo.forumFlags & RS_DISTRIB_AUTHEN_ANON) == 0) {
|
||||
errorState = RS_FEED_ERRORSTATE_FORUM_NO_ANONYMOUS_FORUM;
|
||||
errorState = RS_FEED_ERRORSTATE_PROCESS_FORUM_NOT_ANONYMOUS;
|
||||
} else {
|
||||
forumId = fi->forumId;
|
||||
}
|
||||
} else {
|
||||
errorState = RS_FEED_ERRORSTATE_FORUM_NOT_FOUND;
|
||||
errorState = RS_FEED_ERRORSTATE_PROCESS_FORUM_NOT_FOUND;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* process msgs */
|
||||
if (errorState == RS_FEED_ERRORSTATE_OK) {
|
||||
std::list<RsFeedReaderMsg*>::iterator newMsgIt;
|
||||
for (newMsgIt = msgs.begin(); newMsgIt != msgs.end(); ) {
|
||||
RsFeedReaderMsg *miNew = *newMsgIt;
|
||||
/* search for existing msg */
|
||||
std::map<std::string, RsFeedReaderMsg*>::iterator msgIt;
|
||||
for (msgIt = fi->mMsgs.begin(); msgIt != fi->mMsgs.end(); ++msgIt) {
|
||||
RsFeedReaderMsg *mi = msgIt->second;
|
||||
if (mi->title == miNew->title && mi->link == mi->link && mi->author == mi->author) {
|
||||
/* msg exist */
|
||||
break;
|
||||
/* process msgs */
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
uint32_t newMsgs = 0;
|
||||
#endif
|
||||
|
||||
if (result) {
|
||||
std::list<RsFeedReaderMsg*>::iterator newMsgIt;
|
||||
for (newMsgIt = msgs.begin(); newMsgIt != msgs.end(); ) {
|
||||
RsFeedReaderMsg *miNew = *newMsgIt;
|
||||
/* add new msg */
|
||||
if (fi->preview) {
|
||||
rs_sprintf(miNew->msgId, "preview%d", mNextPreviewMsgId--);
|
||||
} else {
|
||||
rs_sprintf(miNew->msgId, "%lu", mNextMsgId++);
|
||||
}
|
||||
}
|
||||
if (msgIt != fi->mMsgs.end()) {
|
||||
/* msg exists */
|
||||
delete(*newMsgIt);
|
||||
if (forum) {
|
||||
miNew->flag = RS_FEEDMSG_FLAG_DELETED;
|
||||
forumMsgs.push_back(*miNew);
|
||||
// miNew->description.clear();
|
||||
} else {
|
||||
miNew->flag = RS_FEEDMSG_FLAG_NEW;
|
||||
addedMsgs.push_back(miNew->msgId);
|
||||
}
|
||||
fi->mMsgs[miNew->msgId] = miNew;
|
||||
newMsgIt = msgs.erase(newMsgIt);
|
||||
} else {
|
||||
++newMsgIt;
|
||||
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
++newMsgs;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
} else {
|
||||
result = false;
|
||||
}
|
||||
|
||||
fi->content.clear();
|
||||
fi->errorState = errorState;
|
||||
fi->errorString.clear();
|
||||
|
||||
IndicateConfigChanged();
|
||||
}
|
||||
|
||||
if (mNotify) {
|
||||
mNotify->feedChanged(feedId, NOTIFY_TYPE_MOD);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void p3FeedReader::onProcessSuccess_addMsgs(const std::string &feedId, bool result, std::list<RsFeedReaderMsg*> &msgs)
|
||||
{
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_addMsgs - feed " << feedId << " got " << msgs.size() << " messages" << std::endl;
|
||||
#endif
|
||||
|
||||
std::list<std::string> addedMsgs;
|
||||
std::string forumId;
|
||||
std::list<RsFeedReaderMsg> forumMsgs;
|
||||
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
||||
/* find feed */
|
||||
std::map<std::string, RsFeedReaderFeed*>::iterator it = mFeeds.find(feedId);
|
||||
if (it == mFeeds.end()) {
|
||||
/* feed not found */
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_addMsgs - feed " << feedId << " not found" << std::endl;
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
RsFeedReaderFeed *fi = it->second;
|
||||
bool forum = (fi->flag & RS_FEED_FLAG_FORUM);
|
||||
|
||||
if (forum) {
|
||||
forumId = fi->forumId;
|
||||
if (forumId.empty()) {
|
||||
/* don't process messages without forum id */
|
||||
result = false;
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_addMsgs - feed " << fi->feedId << " (" << fi->name << ") don't process messages without forum id" << std::endl;
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_addMsgs - feed " << fi->feedId << " (" << fi->name << ") added " << newMsgs << "/" << msgs.size() << " messages" << std::endl;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
/* process msgs */
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
uint32_t newMsgs = 0;
|
||||
#endif
|
||||
|
||||
if (result) {
|
||||
std::list<RsFeedReaderMsg*>::iterator newMsgIt;
|
||||
for (newMsgIt = msgs.begin(); newMsgIt != msgs.end(); ) {
|
||||
RsFeedReaderMsg *miNew = *newMsgIt;
|
||||
/* add new msg */
|
||||
rs_sprintf(miNew->msgId, "%lu", mNextMsgId++);
|
||||
if (forum) {
|
||||
miNew->flag = RS_FEEDMSG_FLAG_DELETED;
|
||||
forumMsgs.push_back(*miNew);
|
||||
// miNew->description.clear();
|
||||
} else {
|
||||
miNew->flag = RS_FEEDMSG_FLAG_NEW;
|
||||
addedMsgs.push_back(miNew->msgId);
|
||||
}
|
||||
fi->mMsgs[miNew->msgId] = miNew;
|
||||
newMsgIt = msgs.erase(newMsgIt);
|
||||
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
++newMsgs;
|
||||
#endif
|
||||
}
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::onProcessSuccess_addMsgs - feed " << fi->feedId << " (" << fi->name << ") added " << newMsgs << "/" << msgs.size() << " messages" << std::endl;
|
||||
#endif
|
||||
if (!single) {
|
||||
fi->workstate = RsFeedReaderFeed::WAITING;
|
||||
fi->content.clear();
|
||||
fi->errorState = errorState;
|
||||
fi->lastUpdate = time(NULL);
|
||||
}
|
||||
|
||||
fi->workstate = RsFeedReaderFeed::WAITING;
|
||||
fi->content.clear();
|
||||
fi->lastUpdate = time(NULL);
|
||||
|
||||
IndicateConfigChanged();
|
||||
if (!fi->preview) {
|
||||
IndicateConfigChanged();
|
||||
}
|
||||
}
|
||||
|
||||
if (!forumId.empty() && !forumMsgs.empty()) {
|
||||
|
|
@ -1670,7 +1833,7 @@ void p3FeedReader::onProcessSuccess_addMsgs(const std::string &feedId, bool resu
|
|||
}
|
||||
}
|
||||
|
||||
void p3FeedReader::onProcessError(const std::string &feedId, p3FeedReaderThread::ProcessResult result)
|
||||
void p3FeedReader::onProcessError(const std::string &feedId, p3FeedReaderThread::ProcessResult result, const std::string &errorString)
|
||||
{
|
||||
{
|
||||
RsStackMutex stack(mFeedReaderMtx); /******* LOCK STACK MUTEX *********/
|
||||
|
|
@ -1700,17 +1863,22 @@ void p3FeedReader::onProcessError(const std::string &feedId, p3FeedReaderThread:
|
|||
case p3FeedReaderThread::PROCESS_ERROR_INIT:
|
||||
fi->errorState = RS_FEED_ERRORSTATE_PROCESS_INTERNAL_ERROR;
|
||||
break;
|
||||
case p3FeedReaderThread::PROCESS_UNKNOWN_FORMAT:
|
||||
fi->errorState = RS_FEED_ERRORSTATE_PROCESS_UNKNOWN_FORMAT;
|
||||
break;
|
||||
default:
|
||||
fi->errorState = RS_FEED_ERRORSTATE_PROCESS_INTERNAL_ERROR;
|
||||
}
|
||||
|
||||
// fi->errorString = error;
|
||||
fi->errorString = errorString;
|
||||
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::onProcessError - feed " << fi->feedId << " (" << fi->name << ") error process, result = " << result << ", errorState = " << fi->errorState << std::endl;
|
||||
#endif
|
||||
|
||||
IndicateConfigChanged();
|
||||
if (!fi->preview) {
|
||||
IndicateConfigChanged();
|
||||
}
|
||||
}
|
||||
|
||||
if (mNotify) {
|
||||
|
|
@ -1721,6 +1889,7 @@ void p3FeedReader::onProcessError(const std::string &feedId, p3FeedReaderThread:
|
|||
void p3FeedReader::setFeedInfo(const std::string &feedId, const std::string &name, const std::string &description)
|
||||
{
|
||||
bool changed = false;
|
||||
bool preview;
|
||||
std::string forumId;
|
||||
ForumInfo forumInfoNew;
|
||||
|
||||
|
|
@ -1738,6 +1907,7 @@ void p3FeedReader::setFeedInfo(const std::string &feedId, const std::string &nam
|
|||
}
|
||||
|
||||
RsFeedReaderFeed *fi = it->second;
|
||||
preview = fi->preview;
|
||||
if (fi->name != name) {
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReader::setFeedInfo - feed " << fi->feedId << " changed name from " << fi->name << " to " << name << std::endl;
|
||||
|
|
@ -1753,7 +1923,7 @@ void p3FeedReader::setFeedInfo(const std::string &feedId, const std::string &nam
|
|||
changed = true;
|
||||
}
|
||||
|
||||
if ((fi->flag & RS_FEED_FLAG_FORUM) && (fi->flag & RS_FEED_FLAG_UPDATE_FORUM_INFO) && !fi->forumId.empty()) {
|
||||
if ((fi->flag & RS_FEED_FLAG_FORUM) && (fi->flag & RS_FEED_FLAG_UPDATE_FORUM_INFO) && !fi->forumId.empty() && !preview) {
|
||||
/* change forum too */
|
||||
forumId = fi->forumId;
|
||||
librs::util::ConvertUtf8ToUtf16(fi->name, forumInfoNew.forumName);
|
||||
|
|
@ -1763,7 +1933,9 @@ void p3FeedReader::setFeedInfo(const std::string &feedId, const std::string &nam
|
|||
}
|
||||
|
||||
if (changed) {
|
||||
IndicateConfigChanged();
|
||||
if (!preview) {
|
||||
IndicateConfigChanged();
|
||||
}
|
||||
|
||||
if (mNotify) {
|
||||
mNotify->feedChanged(feedId, NOTIFY_TYPE_MOD);
|
||||
|
|
|
|||
|
|
@ -49,33 +49,35 @@ public:
|
|||
virtual bool getStandardProxy(std::string &proxyAddress, uint16_t &proxyPort);
|
||||
virtual void setStandardProxy(bool useProxy, const std::string &proxyAddress, uint16_t proxyPort);
|
||||
|
||||
virtual RsFeedAddResult addFolder(const std::string parentId, const std::string &name, std::string &feedId);
|
||||
virtual RsFeedAddResult setFolder(const std::string &feedId, const std::string &name);
|
||||
virtual RsFeedAddResult addFeed(const FeedInfo &feedInfo, std::string &feedId);
|
||||
virtual RsFeedAddResult setFeed(const std::string &feedId, const FeedInfo &feedInfo);
|
||||
virtual bool removeFeed(const std::string &feedId);
|
||||
virtual void getFeedList(const std::string &parentId, std::list<FeedInfo> &feedInfos);
|
||||
virtual bool getFeedInfo(const std::string &feedId, FeedInfo &feedInfo);
|
||||
virtual bool getMsgInfo(const std::string &feedId, const std::string &msgId, FeedMsgInfo &msgInfo);
|
||||
virtual bool removeMsg(const std::string &feedId, const std::string &msgId);
|
||||
virtual bool removeMsgs(const std::string &feedId, const std::list<std::string> &msgIds);
|
||||
virtual bool getMessageCount(const std::string &feedId, uint32_t *msgCount, uint32_t *newCount, uint32_t *unreadCount);
|
||||
virtual bool getFeedMsgList(const std::string &feedId, std::list<FeedMsgInfo> &msgInfos);
|
||||
virtual bool processFeed(const std::string &feedId);
|
||||
virtual bool setMessageRead(const std::string &feedId, const std::string &msgId, bool read);
|
||||
virtual RsFeedAddResult addFolder(const std::string parentId, const std::string &name, std::string &feedId);
|
||||
virtual RsFeedAddResult setFolder(const std::string &feedId, const std::string &name);
|
||||
virtual RsFeedAddResult addFeed(const FeedInfo &feedInfo, std::string &feedId);
|
||||
virtual RsFeedAddResult setFeed(const std::string &feedId, const FeedInfo &feedInfo);
|
||||
virtual bool removeFeed(const std::string &feedId);
|
||||
virtual bool addPreviewFeed(const FeedInfo &feedInfo, std::string &feedId);
|
||||
virtual void getFeedList(const std::string &parentId, std::list<FeedInfo> &feedInfos);
|
||||
virtual bool getFeedInfo(const std::string &feedId, FeedInfo &feedInfo);
|
||||
virtual bool getMsgInfo(const std::string &feedId, const std::string &msgId, FeedMsgInfo &msgInfo);
|
||||
virtual bool removeMsg(const std::string &feedId, const std::string &msgId);
|
||||
virtual bool removeMsgs(const std::string &feedId, const std::list<std::string> &msgIds);
|
||||
virtual bool getMessageCount(const std::string &feedId, uint32_t *msgCount, uint32_t *newCount, uint32_t *unreadCount);
|
||||
virtual bool getFeedMsgList(const std::string &feedId, std::list<FeedMsgInfo> &msgInfos);
|
||||
virtual bool getFeedMsgIdList(const std::string &feedId, std::list<std::string> &msgIds);
|
||||
virtual bool processFeed(const std::string &feedId);
|
||||
virtual bool setMessageRead(const std::string &feedId, const std::string &msgId, bool read);
|
||||
|
||||
/****************** p3Service STUFF ******************/
|
||||
virtual int tick();
|
||||
|
||||
/****************** internal STUFF *******************/
|
||||
bool getFeedToDownload(RsFeedReaderFeed &feed);
|
||||
bool getFeedToDownload(RsFeedReaderFeed &feed, const std::string &neededFeedId);
|
||||
void onDownloadSuccess(const std::string &feedId, const std::string &content, std::string &icon);
|
||||
void onDownloadError(const std::string &feedId, p3FeedReaderThread::DownloadResult result, const std::string &error);
|
||||
void onDownloadError(const std::string &feedId, p3FeedReaderThread::DownloadResult result, const std::string &errorString);
|
||||
bool onProcessSuccess_filterMsg(const std::string &feedId, std::list<RsFeedReaderMsg*> &msgs);
|
||||
void onProcessSuccess_addMsgs(const std::string &feedId, bool result, std::list<RsFeedReaderMsg*> &msgs);
|
||||
void onProcessError(const std::string &feedId, p3FeedReaderThread::ProcessResult result);
|
||||
void onProcessSuccess_addMsgs(const std::string &feedId, bool result, std::list<RsFeedReaderMsg*> &msgs, bool single);
|
||||
void onProcessError(const std::string &feedId, p3FeedReaderThread::ProcessResult result, const std::string &errorString);
|
||||
|
||||
bool getFeedToProcess(RsFeedReaderFeed &feed);
|
||||
bool getFeedToProcess(RsFeedReaderFeed &feed, const std::string &neededFeedId);
|
||||
|
||||
void setFeedInfo(const std::string &feedId, const std::string &name, const std::string &description);
|
||||
|
||||
|
|
@ -89,14 +91,17 @@ protected:
|
|||
private:
|
||||
void cleanFeeds();
|
||||
void deleteAllMsgs_locked(RsFeedReaderFeed *fi);
|
||||
void stopPreviewThreads_locked();
|
||||
|
||||
std::list<p3FeedReaderThread*> mThreads;
|
||||
uint32_t mNextFeedId;
|
||||
uint32_t mNextMsgId;
|
||||
time_t mLastClean;
|
||||
RsFeedReaderNotify *mNotify;
|
||||
|
||||
RsMutex mFeedReaderMtx;
|
||||
std::list<p3FeedReaderThread*> mThreads;
|
||||
uint32_t mNextFeedId;
|
||||
uint32_t mNextMsgId;
|
||||
int32_t mNextPreviewFeedId;
|
||||
int32_t mNextPreviewMsgId;
|
||||
uint32_t mStandardUpdateInterval;
|
||||
uint32_t mStandardStorageTime;
|
||||
bool mStandardUseProxy;
|
||||
|
|
@ -109,6 +114,10 @@ private:
|
|||
|
||||
RsMutex mProcessMutex;
|
||||
std::list<std::string> mProcessFeeds;
|
||||
|
||||
RsMutex mPreviewMutex;
|
||||
p3FeedReaderThread *mPreviewDownloadThread;
|
||||
p3FeedReaderThread *mPreviewProcessThread;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -23,10 +23,9 @@
|
|||
#include "rsFeedReaderItems.h"
|
||||
#include "util/rsstring.h"
|
||||
#include "util/CURLWrapper.h"
|
||||
#include "util/XMLWrapper.h"
|
||||
#include "util/HTMLWrapper.h"
|
||||
|
||||
#include <libxml/parser.h>
|
||||
#include <libxml/HTMLparser.h>
|
||||
#include <libxml/HTMLtree.h>
|
||||
#include <openssl/evp.h>
|
||||
|
||||
enum FeedFormat { FORMAT_RSS, FORMAT_RDF };
|
||||
|
|
@ -36,23 +35,13 @@ enum FeedFormat { FORMAT_RSS, FORMAT_RDF };
|
|||
*********/
|
||||
#define FEEDREADER_DEBUG
|
||||
|
||||
p3FeedReaderThread::p3FeedReaderThread(p3FeedReader *feedReader, Type type) : RsThread(), mFeedReader(feedReader), mType(type)
|
||||
p3FeedReaderThread::p3FeedReaderThread(p3FeedReader *feedReader, Type type, const std::string &feedId) :
|
||||
RsThread(), mFeedReader(feedReader), mType(type), mFeedId(feedId)
|
||||
{
|
||||
if (type == PROCESS) {
|
||||
mCharEncodingHandler = xmlFindCharEncodingHandler ("UTF8");
|
||||
|
||||
if (!mCharEncodingHandler) {
|
||||
/* no encoding handler found */
|
||||
std::cerr << "p3FeedReaderThread::p3FeedReaderThread - no encoding handler found" << std::endl;
|
||||
}
|
||||
} else {
|
||||
mCharEncodingHandler = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
p3FeedReaderThread::~p3FeedReaderThread()
|
||||
{
|
||||
xmlCharEncCloseFunc((xmlCharEncodingHandlerPtr) mCharEncodingHandler);
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
|
|
@ -73,16 +62,16 @@ void p3FeedReaderThread::run()
|
|||
case DOWNLOAD:
|
||||
{
|
||||
RsFeedReaderFeed feed;
|
||||
if (mFeedReader->getFeedToDownload(feed)) {
|
||||
if (mFeedReader->getFeedToDownload(feed, mFeedId)) {
|
||||
std::string content;
|
||||
std::string icon;
|
||||
std::string error;
|
||||
std::string errorString;
|
||||
|
||||
DownloadResult result = download(feed, content, icon, error);
|
||||
DownloadResult result = download(feed, content, icon, errorString);
|
||||
if (result == DOWNLOAD_SUCCESS) {
|
||||
mFeedReader->onDownloadSuccess(feed.feedId, content, icon);
|
||||
} else {
|
||||
mFeedReader->onDownloadError(feed.feedId, result, error);
|
||||
mFeedReader->onDownloadError(feed.feedId, result, errorString);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -90,31 +79,48 @@ void p3FeedReaderThread::run()
|
|||
case PROCESS:
|
||||
{
|
||||
RsFeedReaderFeed feed;
|
||||
if (mFeedReader->getFeedToProcess(feed)) {
|
||||
if (mFeedReader->getFeedToProcess(feed, mFeedId)) {
|
||||
std::list<RsFeedReaderMsg*> msgs;
|
||||
std::string error;
|
||||
std::string errorString;
|
||||
std::list<RsFeedReaderMsg*>::iterator it;
|
||||
|
||||
ProcessResult result = process(feed, msgs, error);
|
||||
ProcessResult result = process(feed, msgs, errorString);
|
||||
if (result == PROCESS_SUCCESS) {
|
||||
/* first, filter the messages */
|
||||
bool result = mFeedReader->onProcessSuccess_filterMsg(feed.feedId, msgs);
|
||||
if (isRunning()) {
|
||||
if (result) {
|
||||
long todo; // process new items
|
||||
/* second, process the descriptions */
|
||||
for (it = msgs.begin(); it != msgs.end(); ++it) {
|
||||
for (it = msgs.begin(); it != msgs.end(); ) {
|
||||
RsFeedReaderMsg *mi = *it;
|
||||
processMsg(feed, mi);
|
||||
|
||||
if (feed.preview) {
|
||||
/* add every message */
|
||||
it = msgs.erase(it);
|
||||
|
||||
std::list<RsFeedReaderMsg*> msgSingle;
|
||||
msgSingle.push_back(mi);
|
||||
mFeedReader->onProcessSuccess_addMsgs(feed.feedId, result, msgSingle, true);
|
||||
|
||||
/* delete not accepted message */
|
||||
std::list<RsFeedReaderMsg*>::iterator it1;
|
||||
for (it1 = msgSingle.begin(); it1 != msgSingle.end(); ++it1) {
|
||||
delete (*it1);
|
||||
}
|
||||
} else {
|
||||
++it;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* third, add messages */
|
||||
mFeedReader->onProcessSuccess_addMsgs(feed.feedId, result, msgs);
|
||||
mFeedReader->onProcessSuccess_addMsgs(feed.feedId, result, msgs, false);
|
||||
}
|
||||
} else {
|
||||
mFeedReader->onProcessError(feed.feedId, result);
|
||||
mFeedReader->onProcessError(feed.feedId, result, errorString);
|
||||
}
|
||||
|
||||
/* delete not accepted messages */
|
||||
for (it = msgs.begin(); it != msgs.end(); ++it) {
|
||||
delete (*it);
|
||||
}
|
||||
|
|
@ -299,70 +305,6 @@ p3FeedReaderThread::DownloadResult p3FeedReaderThread::download(const RsFeedRead
|
|||
/****************************** Process ************************************/
|
||||
/***************************************************************************/
|
||||
|
||||
static bool convertToString(xmlCharEncodingHandlerPtr charEncodingHandler, const xmlChar *xmlText, std::string &text)
|
||||
{
|
||||
bool result = false;
|
||||
|
||||
xmlBufferPtr in = xmlBufferCreateStatic((void*) xmlText, xmlStrlen(xmlText));
|
||||
xmlBufferPtr out = xmlBufferCreate();
|
||||
int ret = xmlCharEncOutFunc(charEncodingHandler, out, in);
|
||||
if (ret >= 0) {
|
||||
result = true;
|
||||
text = (char*) xmlBufferContent(out);
|
||||
}
|
||||
|
||||
xmlBufferFree(in);
|
||||
xmlBufferFree(out);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static bool convertFromString(xmlCharEncodingHandlerPtr charEncodingHandler, const char *text, xmlChar *&xmlText)
|
||||
{
|
||||
bool result = false;
|
||||
|
||||
xmlBufferPtr in = xmlBufferCreateStatic((void*) text, strlen(text));
|
||||
xmlBufferPtr out = xmlBufferCreate();
|
||||
int ret = xmlCharEncOutFunc(charEncodingHandler, out, in);
|
||||
if (ret >= 0) {
|
||||
result = true;
|
||||
xmlText = xmlBufferDetach(out);
|
||||
}
|
||||
|
||||
xmlBufferFree(in);
|
||||
xmlBufferFree(out);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static xmlNodePtr findNode(xmlNodePtr node, const char *name, bool children = false)
|
||||
{
|
||||
if (node->name) {
|
||||
if (xmlStrcasecmp (node->name, (xmlChar*) name) == 0) {
|
||||
return node;
|
||||
}
|
||||
}
|
||||
|
||||
xmlNodePtr nodeFound = NULL;
|
||||
if (children) {
|
||||
if (node->children) {
|
||||
nodeFound = findNode(node->children, name, children);
|
||||
if (nodeFound) {
|
||||
return nodeFound;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (node->next) {
|
||||
nodeFound = findNode(node->next, name, children);
|
||||
if (nodeFound) {
|
||||
return nodeFound;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static xmlNodePtr getNextItem(FeedFormat feedFormat, xmlNodePtr channel, xmlNodePtr item)
|
||||
{
|
||||
if (!channel) {
|
||||
|
|
@ -384,7 +326,7 @@ static xmlNodePtr getNextItem(FeedFormat feedFormat, xmlNodePtr channel, xmlNode
|
|||
item = item->next;
|
||||
}
|
||||
for (; item; item = item->next) {
|
||||
if (item->type == XML_ELEMENT_NODE && xmlStrcasecmp (item->name, (xmlChar*) "item") == 0) {
|
||||
if (item->type == XML_ELEMENT_NODE && xmlStrcasecmp(item->name, (const xmlChar*) "item") == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -392,70 +334,6 @@ static xmlNodePtr getNextItem(FeedFormat feedFormat, xmlNodePtr channel, xmlNode
|
|||
return item;
|
||||
}
|
||||
|
||||
static bool getChildText(/*xmlCharEncodingHandlerPtr*/ void *charEncodingHandler, xmlNodePtr node, const char *childName, std::string &text)
|
||||
{
|
||||
if (node == NULL || node->children == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
xmlNodePtr child = findNode(node->children, childName, true);
|
||||
if (!child) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (child->type != XML_ELEMENT_NODE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!child->children) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (child->children->type != XML_TEXT_NODE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (child->children->content) {
|
||||
return convertToString((xmlCharEncodingHandlerPtr) charEncodingHandler, child->children->content, text);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static std::string xmlGetAttr(/*xmlCharEncodingHandlerPtr*/ void *charEncodingHandler, xmlNodePtr node, const char *name)
|
||||
{
|
||||
if (!node || !name) {
|
||||
return "";
|
||||
}
|
||||
|
||||
std::string value;
|
||||
|
||||
xmlChar *xmlValue = xmlGetProp(node, (const xmlChar*) name);
|
||||
if (xmlValue) {
|
||||
convertToString((xmlCharEncodingHandlerPtr) charEncodingHandler, xmlValue, value);
|
||||
xmlFree(xmlValue);
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
static bool xmlSetAttr(/*xmlCharEncodingHandlerPtr*/ void *charEncodingHandler, xmlNodePtr node, const char *name, const char *value)
|
||||
{
|
||||
if (!node || !name) {
|
||||
return false;
|
||||
}
|
||||
|
||||
xmlChar *xmlValue = NULL;
|
||||
if (!convertFromString((xmlCharEncodingHandlerPtr) charEncodingHandler, value, xmlValue)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
xmlAttrPtr xmlAttr = xmlSetProp (node, (const xmlChar*) name, xmlValue);
|
||||
xmlFree(xmlValue);
|
||||
|
||||
return xmlAttr != NULL;
|
||||
}
|
||||
|
||||
static void splitString(std::string s, std::vector<std::string> &v, const char d)
|
||||
{
|
||||
v.clear();
|
||||
|
|
@ -919,14 +797,14 @@ p3FeedReaderThread::ProcessResult p3FeedReaderThread::process(const RsFeedReader
|
|||
|
||||
ProcessResult result = PROCESS_SUCCESS;
|
||||
|
||||
xmlDocPtr document = xmlReadDoc((const xmlChar*) feed.content.c_str(), "", NULL, XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_COMPACT | XML_PARSE_NOCDATA);
|
||||
if (document) {
|
||||
xmlNodePtr root = xmlDocGetRootElement(document);
|
||||
XMLWrapper xml;
|
||||
if (xml.readXML(feed.content.c_str())) {
|
||||
xmlNodePtr root = xml.getRootElement();
|
||||
if (root) {
|
||||
FeedFormat feedFormat;
|
||||
if (xmlStrcmp (root->name, (xmlChar*) "rss") == 0) {
|
||||
if (xmlStrcasecmp(root->name, (const xmlChar*) "rss") == 0) {
|
||||
feedFormat = FORMAT_RSS;
|
||||
} else if (xmlStrcmp (root->name, (xmlChar*) "rdf") != 0) {
|
||||
} else if (xmlStrcasecmp (root->name, (const xmlChar*) "rdf") != 0) {
|
||||
feedFormat = FORMAT_RDF;
|
||||
} else {
|
||||
result = PROCESS_UNKNOWN_FORMAT;
|
||||
|
|
@ -934,18 +812,18 @@ p3FeedReaderThread::ProcessResult p3FeedReaderThread::process(const RsFeedReader
|
|||
}
|
||||
|
||||
if (result == PROCESS_SUCCESS) {
|
||||
xmlNodePtr channel = findNode(root->children, "channel");
|
||||
xmlNodePtr channel = xml.findNode(root->children, "channel");
|
||||
if (channel) {
|
||||
/* import header info */
|
||||
if (feed.flag & RS_FEED_FLAG_INFO_FROM_FEED) {
|
||||
std::string title;
|
||||
if (getChildText(mCharEncodingHandler, channel, "title", title) && !title.empty()) {
|
||||
if (xml.getChildText(channel, "title", title) && !title.empty()) {
|
||||
std::string::size_type p;
|
||||
while ((p = title.find_first_of("\r\n")) != std::string::npos) {
|
||||
title.erase(p, 1);
|
||||
}
|
||||
std::string description;
|
||||
getChildText(mCharEncodingHandler, channel, "description", description);
|
||||
xml.getChildText(channel, "description", description);
|
||||
mFeedReader->setFeedInfo(feed.feedId, title, description);
|
||||
}
|
||||
}
|
||||
|
|
@ -958,7 +836,7 @@ p3FeedReaderThread::ProcessResult p3FeedReaderThread::process(const RsFeedReader
|
|||
}
|
||||
|
||||
std::string title;
|
||||
if (!getChildText(mCharEncodingHandler, node, "title", title) || title.empty()) {
|
||||
if (!xml.getChildText(node, "title", title) || title.empty()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -974,8 +852,8 @@ p3FeedReaderThread::ProcessResult p3FeedReaderThread::process(const RsFeedReader
|
|||
item->title = title;
|
||||
|
||||
/* try feedburner:origLink */
|
||||
if (!getChildText(mCharEncodingHandler, node, "origLink", item->link) || item->link.empty()) {
|
||||
getChildText(mCharEncodingHandler, node, "link", item->link);
|
||||
if (!xml.getChildText(node, "origLink", item->link) || item->link.empty()) {
|
||||
xml.getChildText(node, "link", item->link);
|
||||
}
|
||||
|
||||
long todo; // remove sid
|
||||
|
|
@ -1002,15 +880,15 @@ p3FeedReaderThread::ProcessResult p3FeedReaderThread::process(const RsFeedReader
|
|||
// sLink.Delete (nSIDStart, nSIDEnd - nSIDStart);
|
||||
// }
|
||||
|
||||
getChildText(mCharEncodingHandler, node, "author", item->author);
|
||||
xml.getChildText(node, "author", item->author);
|
||||
|
||||
getChildText(mCharEncodingHandler, node, "description", item->description);
|
||||
xml.getChildText(node, "description", item->description);
|
||||
|
||||
std::string pubDate;
|
||||
if (getChildText(mCharEncodingHandler, node, "pubdate", pubDate)) {
|
||||
if (xml.getChildText(node, "pubdate", pubDate)) {
|
||||
item->pubDate = parseRFC822Date(pubDate);
|
||||
}
|
||||
if (getChildText(mCharEncodingHandler, node, "date", pubDate)) {
|
||||
if (xml.getChildText(node, "date", pubDate)) {
|
||||
item->pubDate = parseISO8601Date (pubDate);
|
||||
}
|
||||
|
||||
|
|
@ -1030,8 +908,6 @@ p3FeedReaderThread::ProcessResult p3FeedReaderThread::process(const RsFeedReader
|
|||
result = PROCESS_UNKNOWN_FORMAT;
|
||||
error = "Can't read document";
|
||||
}
|
||||
|
||||
xmlFreeDoc(document);
|
||||
} else {
|
||||
result = PROCESS_ERROR_INIT;
|
||||
}
|
||||
|
|
@ -1101,9 +977,9 @@ bool p3FeedReaderThread::processMsg(const RsFeedReaderFeed &feed, RsFeedReaderMs
|
|||
|
||||
/* process description */
|
||||
long todo; // encoding
|
||||
htmlDocPtr document = htmlReadMemory(msg->description.c_str(), msg->description.length(), url.c_str(), "", HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING | HTML_PARSE_COMPACT);
|
||||
if (document) {
|
||||
xmlNodePtr root = xmlDocGetRootElement(document);
|
||||
HTMLWrapper html;
|
||||
if (html.readHTML(msg->description.c_str(), url.c_str())) {
|
||||
xmlNodePtr root = html.getRootElement();
|
||||
if (root) {
|
||||
/* process all children */
|
||||
std::list<xmlNodePtr> parents;
|
||||
|
|
@ -1118,12 +994,12 @@ bool p3FeedReaderThread::processMsg(const RsFeedReaderFeed &feed, RsFeedReaderMs
|
|||
|
||||
if (node->type == XML_ELEMENT_NODE) {
|
||||
/* check for image */
|
||||
if (strcasecmp((char*) node->name, "img") == 0) {
|
||||
if (xmlStrcasecmp(node->name, (const xmlChar*) "img") == 0) {
|
||||
bool removeImage = true;
|
||||
|
||||
if (feed.flag & RS_FEED_FLAG_EMBED_IMAGES) {
|
||||
/* embed image */
|
||||
std::string src = xmlGetAttr(mCharEncodingHandler, node, "src");
|
||||
std::string src = html.getAttr(node, "src");
|
||||
if (!src.empty()) {
|
||||
/* download image */
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
|
|
@ -1139,7 +1015,7 @@ bool p3FeedReaderThread::processMsg(const RsFeedReaderFeed &feed, RsFeedReaderMs
|
|||
if (toBase64(data, base64)) {
|
||||
std::string imageBase64;
|
||||
rs_sprintf(imageBase64, "data:%s;base64,%s", contentType.c_str(), base64.c_str());
|
||||
if (xmlSetAttr(mCharEncodingHandler, node, "src", imageBase64.c_str())) {
|
||||
if (html.setAttr(node, "src", imageBase64.c_str())) {
|
||||
removeImage = false;
|
||||
}
|
||||
}
|
||||
|
|
@ -1163,26 +1039,20 @@ bool p3FeedReaderThread::processMsg(const RsFeedReaderFeed &feed, RsFeedReaderMs
|
|||
}
|
||||
}
|
||||
|
||||
xmlChar *html = NULL;
|
||||
int htmlSize = 0;
|
||||
htmlDocDumpMemoryFormat(document, &html, &htmlSize, 0);
|
||||
if (html) {
|
||||
convertToString((xmlCharEncodingHandlerPtr) mCharEncodingHandler, html, msg->description);
|
||||
xmlFree(html);
|
||||
if (isRunning()) {
|
||||
if (!html.saveHTML(msg->description)) {
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReaderThread::processHTML - feed " << feed.feedId << " (" << feed.name << ") cannot dump html" << std::endl;
|
||||
#endif
|
||||
result = false;
|
||||
}
|
||||
} else {
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReaderThread::processHTML - feed " << feed.feedId << " (" << feed.name << ") cannot dump html" << std::endl;
|
||||
std::cerr << "p3FeedReaderThread::processHTML - feed " << feed.feedId << " (" << feed.name << ") no root element" << std::endl;
|
||||
#endif
|
||||
result = false;
|
||||
}
|
||||
} else {
|
||||
#ifdef FEEDREADER_DEBUG
|
||||
std::cerr << "p3FeedReaderThread::processHTML - feed " << feed.feedId << " (" << feed.name << ") no root element" << std::endl;
|
||||
#endif
|
||||
result = false;
|
||||
}
|
||||
|
||||
xmlFreeDoc(document);
|
||||
}
|
||||
|
||||
return result;
|
||||
|
|
|
|||
|
|
@ -43,8 +43,7 @@ public:
|
|||
DOWNLOAD_ERROR,
|
||||
DOWNLOAD_UNKNOWN_CONTENT_TYPE,
|
||||
DOWNLOAD_NOT_FOUND,
|
||||
DOWNLOAD_UNKOWN_RESPONSE_CODE,
|
||||
DOWNLOAD_INTERNAL_ERROR
|
||||
DOWNLOAD_UNKOWN_RESPONSE_CODE
|
||||
};
|
||||
enum ProcessResult
|
||||
{
|
||||
|
|
@ -54,9 +53,11 @@ public:
|
|||
};
|
||||
|
||||
public:
|
||||
p3FeedReaderThread(p3FeedReader *feedReader, Type type);
|
||||
p3FeedReaderThread(p3FeedReader *feedReader, Type type, const std::string &feedId);
|
||||
virtual ~p3FeedReaderThread();
|
||||
|
||||
std::string getFeedId() { return mFeedId; }
|
||||
|
||||
private:
|
||||
virtual void run();
|
||||
|
||||
|
|
@ -68,7 +69,7 @@ private:
|
|||
|
||||
p3FeedReader *mFeedReader;
|
||||
Type mType;
|
||||
/*xmlCharEncodingHandlerPtr*/ void *mCharEncodingHandler;
|
||||
std::string mFeedId;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -50,6 +50,7 @@ void RsFeedReaderFeed::clear()
|
|||
errorState = RS_FEED_ERRORSTATE_OK;
|
||||
errorString.clear();
|
||||
|
||||
preview = false;
|
||||
workstate = WAITING;
|
||||
content.clear();
|
||||
}
|
||||
|
|
@ -176,7 +177,9 @@ RsFeedReaderFeed *RsFeedReaderSerialiser::deserialiseFeed(void *data, uint32_t *
|
|||
ok &= getRawUInt32(data, rssize, &offset, &(item->storageTime));
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->flag));
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->forumId);
|
||||
ok &= getRawUInt32(data, rssize, &offset, &(item->errorState));
|
||||
uint32_t errorState = 0;
|
||||
ok &= getRawUInt32(data, rssize, &offset, &errorState);
|
||||
item->errorState = (RsFeedReaderErrorState) errorState;
|
||||
ok &= GetTlvString(data, rssize, &offset, TLV_TYPE_STR_VALUE, item->errorString);
|
||||
|
||||
if (offset != rssize)
|
||||
|
|
|
|||
|
|
@ -32,20 +32,6 @@ const uint8_t RS_PKT_SUBTYPE_FEEDREADER_MSG = 0x03;
|
|||
|
||||
/**************************************************************************/
|
||||
|
||||
#define RS_FEED_ERRORSTATE_OK 0
|
||||
#define RS_FEED_ERRORSTATE_DOWNLOAD_INTERNAL_ERROR 1
|
||||
#define RS_FEED_ERRORSTATE_DOWNLOAD_ERROR 2
|
||||
#define RS_FEED_ERRORSTATE_DOWNLOAD_UNKNOWN_CONTENT_TYPE 3
|
||||
#define RS_FEED_ERRORSTATE_DOWNLOAD_NOT_FOUND 4
|
||||
#define RS_FEED_ERRORSTATE_DOWNLOAD_UNKOWN_RESPONSE_CODE 5
|
||||
|
||||
#define RS_FEED_ERRORSTATE_PROCESS_INTERNAL_ERROR 50
|
||||
|
||||
#define RS_FEED_ERRORSTATE_FORUM_CREATE 100
|
||||
#define RS_FEED_ERRORSTATE_FORUM_NOT_FOUND 101
|
||||
#define RS_FEED_ERRORSTATE_FORUM_NO_ADMIN 102
|
||||
#define RS_FEED_ERRORSTATE_FORUM_NO_ANONYMOUS_FORUM 103
|
||||
|
||||
#define RS_FEED_FLAG_FOLDER 0x001
|
||||
#define RS_FEED_FLAG_INFO_FROM_FEED 0x002
|
||||
#define RS_FEED_FLAG_STANDARD_STORAGE_TIME 0x004
|
||||
|
|
@ -76,25 +62,26 @@ public:
|
|||
virtual void clear();
|
||||
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
|
||||
|
||||
std::string feedId;
|
||||
std::string parentId;
|
||||
std::string name;
|
||||
std::string url;
|
||||
std::string user;
|
||||
std::string password;
|
||||
std::string proxyAddress;
|
||||
uint16_t proxyPort;
|
||||
uint32_t updateInterval;
|
||||
time_t lastUpdate;
|
||||
uint32_t flag; // RS_FEED_FLAG_...
|
||||
std::string forumId;
|
||||
uint32_t storageTime;
|
||||
std::string description;
|
||||
std::string icon;
|
||||
uint32_t errorState;
|
||||
std::string errorString;
|
||||
std::string feedId;
|
||||
std::string parentId;
|
||||
std::string name;
|
||||
std::string url;
|
||||
std::string user;
|
||||
std::string password;
|
||||
std::string proxyAddress;
|
||||
uint16_t proxyPort;
|
||||
uint32_t updateInterval;
|
||||
time_t lastUpdate;
|
||||
uint32_t flag; // RS_FEED_FLAG_...
|
||||
std::string forumId;
|
||||
uint32_t storageTime;
|
||||
std::string description;
|
||||
std::string icon;
|
||||
RsFeedReaderErrorState errorState;
|
||||
std::string errorString;
|
||||
|
||||
/* Not Serialised */
|
||||
bool preview;
|
||||
WorkState workstate;
|
||||
std::string content;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,136 +0,0 @@
|
|||
/****************************************************************
|
||||
* RetroShare GUI is distributed under the following license:
|
||||
*
|
||||
* Copyright (C) 2012 by Thunder
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
****************************************************************/
|
||||
|
||||
#include "CURLWrapper.h"
|
||||
|
||||
//static int progressCallback (void *clientp, double /*dltotal*/, double /*dlnow*/, double /*ultotal*/, double /*ulnow*/)
|
||||
//{
|
||||
// p3FeedReaderThread *thread = (p3FeedReaderThread*) clientp;
|
||||
|
||||
// if (!thread->isRunning()) {
|
||||
// /* thread was stopped */
|
||||
// return 1;
|
||||
// }
|
||||
|
||||
// long todo; // show progress in gui
|
||||
|
||||
// return 0;
|
||||
//}
|
||||
|
||||
CURLWrapper::CURLWrapper(const std::string &proxy)
|
||||
{
|
||||
mCurl = curl_easy_init();
|
||||
if (mCurl) {
|
||||
curl_easy_setopt(mCurl, CURLOPT_NOPROGRESS, 0);
|
||||
// curl_easy_setopt(mCurl, CURLOPT_PROGRESSFUNCTION, progressCallback);
|
||||
// curl_easy_setopt(mCurl, CURLOPT_PROGRESSDATA, feedReader);
|
||||
curl_easy_setopt(mCurl, CURLOPT_FOLLOWLOCATION, 1);
|
||||
curl_easy_setopt(mCurl, CURLOPT_CONNECTTIMEOUT, 60);
|
||||
curl_easy_setopt(mCurl, CURLOPT_TIMEOUT, 120);
|
||||
|
||||
if (!proxy.empty()) {
|
||||
curl_easy_setopt(mCurl, CURLOPT_PROXY, proxy.c_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CURLWrapper::~CURLWrapper()
|
||||
{
|
||||
if (mCurl) {
|
||||
curl_easy_cleanup(mCurl);
|
||||
}
|
||||
}
|
||||
|
||||
static size_t writeFunctionString (void *ptr, size_t size, size_t nmemb, void *stream)
|
||||
{
|
||||
std::string *s = (std::string*) stream;
|
||||
s->append ((char*) ptr, size * nmemb);
|
||||
|
||||
return nmemb * size;
|
||||
}
|
||||
|
||||
CURLcode CURLWrapper::downloadText(const std::string &link, std::string &data)
|
||||
{
|
||||
data.clear();
|
||||
|
||||
if (!mCurl) {
|
||||
return CURLE_FAILED_INIT;
|
||||
}
|
||||
|
||||
curl_easy_setopt(mCurl, CURLOPT_URL, link.c_str());
|
||||
curl_easy_setopt(mCurl, CURLOPT_WRITEFUNCTION, writeFunctionString);
|
||||
curl_easy_setopt(mCurl, CURLOPT_WRITEDATA, &data);
|
||||
|
||||
return curl_easy_perform(mCurl);
|
||||
}
|
||||
|
||||
static size_t writeFunctionBinary (void *ptr, size_t size, size_t nmemb, void *stream)
|
||||
{
|
||||
std::vector<unsigned char> *bytes = (std::vector<unsigned char>*) stream;
|
||||
|
||||
std::vector<unsigned char> newBytes;
|
||||
newBytes.resize(size * nmemb);
|
||||
memcpy(newBytes.data(), ptr, newBytes.size());
|
||||
|
||||
bytes->insert(bytes->end(), newBytes.begin(), newBytes.end());
|
||||
|
||||
return nmemb * size;
|
||||
}
|
||||
|
||||
CURLcode CURLWrapper::downloadBinary(const std::string &link, std::vector<unsigned char> &data)
|
||||
{
|
||||
data.clear();
|
||||
|
||||
if (!mCurl) {
|
||||
return CURLE_FAILED_INIT;
|
||||
}
|
||||
|
||||
curl_easy_setopt(mCurl, CURLOPT_NOPROGRESS, 1);
|
||||
curl_easy_setopt(mCurl, CURLOPT_URL, link.c_str());
|
||||
curl_easy_setopt(mCurl, CURLOPT_WRITEFUNCTION, writeFunctionBinary);
|
||||
curl_easy_setopt(mCurl, CURLOPT_WRITEDATA, &data);
|
||||
|
||||
return curl_easy_perform(mCurl);
|
||||
}
|
||||
|
||||
long CURLWrapper::longInfo(CURLINFO info)
|
||||
{
|
||||
if (!mCurl) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
long value;
|
||||
curl_easy_getinfo(mCurl, info, &value);
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
std::string CURLWrapper::stringInfo(CURLINFO info)
|
||||
{
|
||||
if (!mCurl) {
|
||||
return "";
|
||||
}
|
||||
|
||||
char *value;
|
||||
curl_easy_getinfo(mCurl, info, &value);
|
||||
|
||||
return value ? value : "";
|
||||
}
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
/****************************************************************
|
||||
* RetroShare GUI is distributed under the following license:
|
||||
*
|
||||
* Copyright (C) 2012 by Thunder
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
****************************************************************/
|
||||
|
||||
#ifndef CURLWRAPPER
|
||||
#define CURLWRAPPER
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <curl/curl.h>
|
||||
|
||||
class CURLWrapper
|
||||
{
|
||||
public:
|
||||
CURLWrapper(const std::string &proxy);
|
||||
~CURLWrapper();
|
||||
|
||||
CURLcode downloadText(const std::string &link, std::string &data);
|
||||
CURLcode downloadBinary(const std::string &link, std::vector<unsigned char> &data);
|
||||
|
||||
long responseCode() { return longInfo(CURLINFO_RESPONSE_CODE); }
|
||||
std::string contentType() { return stringInfo(CURLINFO_CONTENT_TYPE); }
|
||||
std::string effectiveUrl() { return stringInfo(CURLINFO_EFFECTIVE_URL); }
|
||||
|
||||
protected:
|
||||
long longInfo(CURLINFO info);
|
||||
std::string stringInfo(CURLINFO info);
|
||||
|
||||
private:
|
||||
CURL *mCurl;
|
||||
};
|
||||
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue