frodovdr
/
vdr-plugin-scraper2vdr
mirror of https://projects.vdr-developer.org/git/vdr-plugin-scraper2vdr.git
1
0
Fork 0
Code Issues Releases Wiki Activity

some more fixes

This commit is contained in:
louis 2014-05-09 16:53:56 +02:00
parent 5d7fb01f67
commit 31f55fb489
12 changed files with 369 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
HISTORY
View File

@ -14,7 +14,9 @@ Version 0.1.0
- fixed bug that scraped events are not displayed randomly
Version 0.1.1
- ...
Version 0.1.2
- update of db api
- prepare statements only once
- added statement statistic
@ -23,5 +25,3 @@ Version 0.1.1
- added path detection for libmysql
- fixed epgd state detection
- added cppcheck to Makefile
Version 0.1.2

5
Makefile
View File

@ -4,10 +4,11 @@
# $Id$
# External image lib to use: imagemagick, graphicsmagick
IMAGELIB = imagemagick
PLUGIN = scraper2vdr
HLIB = -L./lib -lhorchi
HLIB = -L./lib -lhorchi
### The version number of this plugin (taken from the main source file):
@ -36,7 +37,7 @@ APIVERSION = $(call PKGCFG,apiversion)
-include $(PLGCFG)
LIBS = $(HLIB) $(shell mysql_config --libs_r) -luuid
LIBS = $(HLIB) $(shell mysql_config --libs_r) -luuid -lcrypto
### The name of the distribution archive:

2
lib/Makefile
View File

@ -32,7 +32,7 @@ CFLAGS += -fPIC -Wreturn-type -Wall -Wno-parentheses -Wformat -pedantic -Wunused
CFLAGS += $(shell mysql_config --include)
DEFINES = -DPLGDIR='"."' -DUSEUUID -DUSEMD5
DEFINES = -DPLGDIR='"."' -DUSEUUID -DUSEMD5 -USELIBXML
all: lib $(TEST) $(DEMO)
lib: $(LIBTARGET).a

130
lib/common.c
View File

@ -25,21 +25,20 @@
# include <archive_entry.h>
#endif
#ifdef VDR_PLUGIN
# include <vdr/thread.h>
#endif
#include "common.h"
#include "config.h"
#ifdef VDR_PLUGIN
cMutex logMutex;
#endif
cMyMutex logMutex;
//***************************************************************************
// Debug
//***************************************************************************
const char* getLogPrefix()
{
return logPrefix;
}
void tell(int eloquence, const char* format, ...)
{
if (EPG2VDRConfig.loglevel < eloquence)
@ -49,15 +48,12 @@ void tell(int eloquence, const char* format, ...)
char t[sizeBuffer+100]; *t = 0;
va_list ap;
#ifdef VDR_PLUGIN
cMutexLock lock(&logMutex);
#endif
logMutex.Lock();
va_start(ap, format);
#ifdef VDR_PLUGIN
snprintf(t, sizeBuffer, LOG_PREFIX);
#endif
if (getLogPrefix())
snprintf(t, sizeBuffer, "%s", getLogPrefix());
vsnprintf(t+strlen(t), sizeBuffer-strlen(t), format, ap);
@ -75,11 +71,12 @@ void tell(int eloquence, const char* format, ...)
tp.tv_usec / 1000);
printf("%s %s\n", buf, t);
}
else
syslog(LOG_ERR, "%s", t);
logMutex.Unlock();
va_end(ap);
}
@ -959,12 +956,103 @@ int unzip(const char* file, const char* filter, char*& buffer, int& size, char*
#endif
//***************************************************************************
// Class LogDuration
// cMyMutex
//***************************************************************************
#ifdef VDR_PLUGIN
cMyMutex::cMyMutex (void)
{
locked = 0;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
pthread_mutex_init(&mutex, &attr);
}
# include <vdr/plugin.h>
cMyMutex::~cMyMutex()
{
pthread_mutex_destroy(&mutex);
}
void cMyMutex::Lock(void)
{
pthread_mutex_lock(&mutex);
locked++;
}
void cMyMutex::Unlock(void)
{
if (!--locked)
pthread_mutex_unlock(&mutex);
}
//***************************************************************************
// cMyTimeMs
//***************************************************************************
cMyTimeMs::cMyTimeMs(int Ms)
{
if (Ms >= 0)
Set(Ms);
else
begin = 0;
}
uint64_t cMyTimeMs::Now(void)
{
#define MIN_RESOLUTION 5 // ms
static bool initialized = false;
static bool monotonic = false;
struct timespec tp;
if (!initialized) {
// check if monotonic timer is available and provides enough accurate resolution:
if (clock_getres(CLOCK_MONOTONIC, &tp) == 0) {
// long Resolution = tp.tv_nsec;
// require a minimum resolution:
if (tp.tv_sec == 0 && tp.tv_nsec <= MIN_RESOLUTION * 1000000) {
if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0) {
monotonic = true;
}
else
tell(0, "cMyTimeMs: clock_gettime(CLOCK_MONOTONIC) failed");
}
else
tell(0, "cMyTimeMs: not using monotonic clock - resolution is too bad (%ld s %ld ns)", tp.tv_sec, tp.tv_nsec);
}
else
tell(0, "cMyTimeMs: clock_getres(CLOCK_MONOTONIC) failed");
initialized = true;
}
if (monotonic) {
if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
return (uint64_t(tp.tv_sec)) * 1000 + tp.tv_nsec / 1000000;
tell(0, "cMyTimeMs: clock_gettime(CLOCK_MONOTONIC) failed");
monotonic = false;
// fall back to gettimeofday()
}
struct timeval t;
if (gettimeofday(&t, NULL) == 0)
return (uint64_t(t.tv_sec)) * 1000 + t.tv_usec / 1000;
return 0;
}
void cMyTimeMs::Set(int Ms)
{
begin = Now() + Ms;
}
bool cMyTimeMs::TimedOut(void)
{
return Now() >= begin;
}
uint64_t cMyTimeMs::Elapsed(void)
{
return Now() - begin;
}
//***************************************************************************
// Class LogDuration
//***************************************************************************
LogDuration::LogDuration(const char* aMessage, int aLogLevel)
{
@ -973,23 +1061,21 @@ LogDuration::LogDuration(const char* aMessage, int aLogLevel)
// at last !
durationStart = cTimeMs::Now();
durationStart = cMyTimeMs::Now();
}
LogDuration::~LogDuration()
{
tell(logLevel, "duration '%s' was (%ldms)",
message, cTimeMs::Now() - durationStart);
message, cMyTimeMs::Now() - durationStart);
}
void LogDuration::show(const char* label)
{
tell(logLevel, "elapsed '%s' at '%s' was (%ldms)",
message, label, cTimeMs::Now() - durationStart);
message, label, cMyTimeMs::Now() - durationStart);
}
#endif
//***************************************************************************
// Get Unique ID
//***************************************************************************

55
lib/common.h
View File

@ -15,9 +15,10 @@
#include <openssl/md5.h> // MD5_*
#ifdef VDR_PLUGIN
# include <vdr/tools.h>
#endif
//#ifdef VDR_PLUGIN
//# include <vdr/tools.h>
//# include <vdr/thread.h>
//#endif
#ifdef USELIBXML
# include <libxslt/transform.h>
@ -29,10 +30,10 @@
// Misc
//***************************************************************************
#ifndef VDR_PLUGIN
inline long min(long a, long b) { return a < b ? a : b; }
inline long max(long a, long b) { return a > b ? a : b; }
#endif
// #ifndef VDR_PLUGIN
inline long min(long a, long b) { return a < b ? a : b; }
inline long max(long a, long b) { return a > b ? a : b; }
// #endif
enum Misc
{
@ -69,6 +70,9 @@ const char* toCase(Case cs, char* str);
// Tell
//***************************************************************************
extern const char* logPrefix;
const char* getLogPrefix();
void __attribute__ ((format(printf, 2, 3))) tell(int eloquence, const char* format, ...);
//***************************************************************************
@ -220,7 +224,41 @@ int unzip(const char* file, const char* filter, char*& buffer,
int& size, char* entryName);
#endif
#ifdef VDR_PLUGIN
//***************************************************************************
// cMyMutex
//***************************************************************************
class cMyMutex
{
friend class cCondVar;
private:
pthread_mutex_t mutex;
int locked;
public:
cMyMutex(void);
~cMyMutex();
void Lock(void);
void Unlock(void);
};
//***************************************************************************
// cMyTimeMs
//***************************************************************************
class cMyTimeMs
{
private:
uint64_t begin;
public:
cMyTimeMs(int Ms = 0);
static uint64_t Now(void);
void Set(int Ms = 0);
bool TimedOut(void);
uint64_t Elapsed(void);
};
//***************************************************************************
// Log Duration
@ -241,7 +279,6 @@ class LogDuration
uint64_t durationStart;
int logLevel;
};
#endif
//***************************************************************************
#endif //___COMMON_H

10
lib/config.c
View File

@ -39,10 +39,13 @@ cEPG2VDRConfig::cEPG2VDRConfig(void)
seriesPort = 2006;
storeSeriesToFs = no;
#ifdef VDR_PLUGIN
// for VDR_PLUGIN
activeOnEpgd = no;
scheduleBoot = no;
#else
// for epgd
sstrcpy(cachePath, "/var/cache/epgd", sizeof(cachePath));
sstrcpy(httpPath, "/var/epgd/www", sizeof(httpPath));
sstrcpy(pluginPath, PLGDIR, sizeof(pluginPath));
@ -51,7 +54,8 @@ cEPG2VDRConfig::cEPG2VDRConfig(void)
updateThreshold = 200;
maintanance = no;
httpPort = 9999;
#endif
//
sstrcpy(dbHost, "localhost", sizeof(dbHost));
dbPort = 3306;

10
lib/config.h
View File

@ -42,10 +42,13 @@ struct cEPG2VDRConfig
int seriesPort;
int storeSeriesToFs;
#ifdef VDR_PLUGIN
// for VDR_PLUGIN
int activeOnEpgd;
int scheduleBoot;
#else
// for epgd
char cachePath[256+TB];
char httpPath[256+TB];
char pluginPath[256+TB];
@ -54,7 +57,8 @@ struct cEPG2VDRConfig
int updateThreshold;
int maintanance;
int httpPort;
#endif
//
char dbHost[100+TB];
int dbPort;

1
lib/demo.c
View File

@ -7,6 +7,7 @@
#include "tabledef.h"
cDbConnection* connection = 0;
const char* logPrefix = "demo";
//***************************************************************************
// Init Connection

83
lib/test.c
View File

@ -13,25 +13,7 @@
#include "dbdict.h"
cDbConnection* connection = 0;
//***************************************************************************
//
//***************************************************************************
class cTimeMs
{
private:
uint64_t begin;
public:
cTimeMs(int Ms = 0);
static uint64_t Now(void);
void Set(int Ms = 0);
bool TimedOut(void);
uint64_t Elapsed(void);
};
const char* logPrefix = "test";
//***************************************************************************
// Init Connection
@ -273,69 +255,6 @@ void chkStatement3()
delete mapDb;
}
// --- cTimeMs ---------------------------------------------------------------
cTimeMs::cTimeMs(int Ms)
{
if (Ms >= 0)
Set(Ms);
else
begin = 0;
}
uint64_t cTimeMs::Now(void)
{
#define MIN_RESOLUTION 5 // ms
static bool initialized = false;
static bool monotonic = false;
struct timespec tp;
if (!initialized) {
// check if monotonic timer is available and provides enough accurate resolution:
if (clock_getres(CLOCK_MONOTONIC, &tp) == 0) {
// long Resolution = tp.tv_nsec;
// require a minimum resolution:
if (tp.tv_sec == 0 && tp.tv_nsec <= MIN_RESOLUTION * 1000000) {
if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0) {
monotonic = true;
}
else
tell(0, "cTimeMs: clock_gettime(CLOCK_MONOTONIC) failed");
}
else
tell(0, "cTimeMs: not using monotonic clock - resolution is too bad (%ld s %ld ns)", tp.tv_sec, tp.tv_nsec);
}
else
tell(0, "cTimeMs: clock_getres(CLOCK_MONOTONIC) failed");
initialized = true;
}
if (monotonic) {
if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
return (uint64_t(tp.tv_sec)) * 1000 + tp.tv_nsec / 1000000;
tell(0, "cTimeMs: clock_gettime(CLOCK_MONOTONIC) failed");
monotonic = false;
// fall back to gettimeofday()
}
struct timeval t;
if (gettimeofday(&t, NULL) == 0)
return (uint64_t(t.tv_sec)) * 1000 + t.tv_usec / 1000;
return 0;
}
void cTimeMs::Set(int Ms)
{
begin = Now() + Ms;
}
bool cTimeMs::TimedOut(void)
{
return Now() >= begin;
}
uint64_t cTimeMs::Elapsed(void)
{
return Now() - begin;
}
//***************************************************************************
//
//***************************************************************************

1
scraper2vdr.c
View File

@ -7,6 +7,7 @@
*/
#include "scraper2vdr.h"
const char* logPrefix = LOG_PREFIX;
#if defined (APIVERSNUM) && (APIVERSNUM < 10600)
# error VDR API versions < 1.6.0 are not supported !

2
scrapmanager.c
View File

@ -354,7 +354,7 @@ void cScrapManager::DumpMovies(void) {
}
void cScrapManager::DumpRecordings(void) {
tell(0, "%d recordings in memory:", (int)recordings.size());
tell(0, "%ld recordings in memory:", recordings.size());
for (map<sRecordingsKey, sEventsValue>::iterator it = recordings.begin(); it != recordings.end(); it++) {
sRecordingsKey key = it->first;
sEventsValue val = it->second;