int
lobject_seek(lobjectObject *self, int pos, int whence)
{
PGresult *pgres = NULL;
char *error = NULL;
int where;
Dprintf("lobject_seek: fd = %d, pos = %d, whence = %d",
self->fd, pos, whence);
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
where = lo_lseek(self->conn->pgconn, self->fd, pos, whence);
Dprintf("lobject_seek: where = %d", where);
if (where < 0)
collect_error(self->conn, &error);
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (where < 0)
pq_complete_error(self->conn, &pgres, &error);
return where;
}
int
lobject_export(lobjectObject *self, const char *filename)
{
PGresult *pgres = NULL;
char *error = NULL;
int retvalue;
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
retvalue = pq_begin_locked(self->conn, &pgres, &error);
if (retvalue < 0)
goto end;
retvalue = lo_export(self->conn->pgconn, self->oid, filename);
if (retvalue < 0)
collect_error(self->conn, &error);
end:
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (retvalue < 0)
pq_complete_error(self->conn, &pgres, &error);
return retvalue;
}
Py_ssize_t
lobject_write(lobjectObject *self, const char *buf, size_t len)
{
Py_ssize_t written;
PGresult *pgres = NULL;
char *error = NULL;
Dprintf("lobject_writing: fd = %d, len = %d",
self->fd, len);
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
PQsetnonblocking(self->conn->pgconn, 0);
written = lo_write(self->conn->pgconn, self->fd, buf, len);
if (written < 0)
collect_error(self->conn, &error);
PQsetnonblocking(self->conn->pgconn, 1);
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (written < 0)
pq_complete_error(self->conn, &pgres, &error);
return written;
}
RAISES_NEG int
lobject_truncate(lobjectObject *self, size_t len)
{
int retvalue;
PGresult *pgres = NULL;
char *error = NULL;
Dprintf("lobject_truncate: fd = %d, len = " FORMAT_CODE_SIZE_T,
self->fd, len);
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
#ifdef HAVE_LO64
if (self->conn->server_version < 90300) {
retvalue = lo_truncate(self->conn->pgconn, self->fd, len);
} else {
retvalue = lo_truncate64(self->conn->pgconn, self->fd, len);
}
#else
retvalue = lo_truncate(self->conn->pgconn, self->fd, len);
#endif
Dprintf("lobject_truncate: result = %d", retvalue);
if (retvalue < 0)
collect_error(self->conn, &error);
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (retvalue < 0)
pq_complete_error(self->conn, &pgres, &error);
return retvalue;
}
int
lobject_unlink(lobjectObject *self)
{
PGresult *pgres = NULL;
char *error = NULL;
int retvalue = -1;
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
retvalue = pq_begin_locked(self->conn, &pgres, &error);
if (retvalue < 0)
goto end;
/* first we make sure the lobject is closed and then we unlink */
retvalue = lobject_close_locked(self, &error);
if (retvalue < 0)
goto end;
retvalue = lo_unlink(self->conn->pgconn, self->oid);
if (retvalue < 0)
collect_error(self->conn, &error);
end:
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (retvalue < 0)
pq_complete_error(self->conn, &pgres, &error);
return retvalue;
}
int
lobject_truncate(lobjectObject *self, size_t len)
{
int retvalue;
PGresult *pgres = NULL;
char *error = NULL;
Dprintf("lobject_truncate: fd = %d, len = " FORMAT_CODE_PY_SSIZE_T,
self->fd, len);
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
retvalue = lo_truncate(self->conn->pgconn, self->fd, len);
Dprintf("lobject_truncate: result = %d", retvalue);
if (retvalue < 0)
collect_error(self->conn, &error);
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (retvalue < 0)
pq_complete_error(self->conn, &pgres, &error);
return retvalue;
}
RAISES_NEG Py_ssize_t
lobject_tell(lobjectObject *self)
{
PGresult *pgres = NULL;
char *error = NULL;
Py_ssize_t where;
Dprintf("lobject_tell: fd = %d", self->fd);
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
#ifdef HAVE_LO64
if (self->conn->server_version < 90300) {
where = (Py_ssize_t)lo_tell(self->conn->pgconn, self->fd);
} else {
where = (Py_ssize_t)lo_tell64(self->conn->pgconn, self->fd);
}
#else
where = (Py_ssize_t)lo_tell(self->conn->pgconn, self->fd);
#endif
Dprintf("lobject_tell: where = " FORMAT_CODE_PY_SSIZE_T, where);
if (where < 0)
collect_error(self->conn, &error);
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (where < 0)
pq_complete_error(self->conn, &pgres, &error);
return where;
}
RAISES_NEG static int
lobject_close_locked(lobjectObject *self, char **error)
{
int retvalue;
Dprintf("lobject_close_locked: conn->closed %ld", self->conn->closed);
switch (self->conn->closed) {
case 0:
/* Connection is open, go ahead */
break;
case 1:
/* Connection is closed, return a success */
return 0;
break;
default:
*error = strdup("the connection is broken");
return -1;
break;
}
if (self->conn->autocommit ||
self->conn->mark != self->mark ||
self->fd == -1)
return 0;
retvalue = lo_close(self->conn->pgconn, self->fd);
self->fd = -1;
if (retvalue < 0)
collect_error(self->conn, error);
return retvalue;
}
static gint
list_domains_work(gpointer data)
{
VmonRequest *req = data;
virDomainPtr *domains;
size_t i;
int ret = -1;
int err = 0;
ret = virConnectListAllDomains(req->ctx->conn,
&domains,
req->ctx->flags);
if (ret < 0) {
collect_error(req, ret, FALSE);
return ret;
}
for (i = 0; i < (size_t)ret; i++) {
VmonRequest vreq;
memcpy(&vreq, req, sizeof(vreq));
vreq.dom = domains[i];
err = executor_dispatch(vreq.ctx->executor,
sample_domain_work,
sampling_collect,
&vreq,
sizeof(vreq),
vreq.ctx->conf.timeout);
if (err) {
collect_error(&vreq, err, FALSE);
}
}
free(domains);
return (err) ?err :0;
}
static gint
sampling_collect(gpointer data, gint error, gboolean timeout)
{
VmonRequest *req = data;
gboolean ret;
if (error || timeout) {
ret = collect_error(req, error, timeout);
} else {
ret = collect_success(req);
}
if (req->dom) {
virDomainFree(req->dom);
}
return ret;
}
static int
lobject_close_locked(lobjectObject *self, char **error)
{
int retvalue;
if (self->conn->isolation_level == 0 ||
self->conn->mark != self->mark ||
self->fd == -1)
return 0;
retvalue = lo_close(self->conn->pgconn, self->fd);
self->fd = -1;
if (retvalue < 0)
collect_error(self->conn, error);
return retvalue;
}
Py_ssize_t
lobject_read(lobjectObject *self, char *buf, size_t len)
{
Py_ssize_t n_read;
PGresult *pgres = NULL;
char *error = NULL;
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
n_read = lo_read(self->conn->pgconn, self->fd, buf, len);
if (n_read < 0)
collect_error(self->conn, &error);
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (n_read < 0)
pq_complete_error(self->conn, &pgres, &error);
return n_read;
}
int
lobject_open(lobjectObject *self, connectionObject *conn,
Oid oid, int mode, Oid new_oid, const char *new_file)
{
int retvalue = -1;
PGresult *pgres = NULL;
char *error = NULL;
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
retvalue = pq_begin_locked(self->conn, &pgres, &error);
if (retvalue < 0)
goto end;
/* if the oid is InvalidOid we create a new lob before opening it
or we import a file from the FS, depending on the value of
new_name */
if (oid == InvalidOid) {
if (new_file)
self->oid = lo_import(self->conn->pgconn, new_file);
else
self->oid = lo_create(self->conn->pgconn, new_oid);
Dprintf("lobject_open: large object created with oid = %d",
self->oid);
if (self->oid == InvalidOid) {
collect_error(self->conn, &error);
retvalue = -1;
goto end;
}
mode = INV_WRITE;
}
else {
self->oid = oid;
if (mode == 0) mode = INV_READ;
}
/* if the oid is a real one we try to open with the given mode,
unless the mode is -1, meaning "don't open!" */
if (mode != -1) {
self->fd = lo_open(self->conn->pgconn, self->oid, mode);
Dprintf("lobject_open: large object opened with fd = %d",
self->fd);
if (self->fd == -1) {
collect_error(self->conn, &error);
retvalue = -1;
goto end;
}
}
/* set the mode for future reference */
switch (mode) {
case -1:
self->smode = "n"; break;
case INV_READ:
self->smode = "r"; break;
case INV_WRITE:
self->smode = "w"; break;
case INV_READ+INV_WRITE:
self->smode = "rw"; break;
}
retvalue = 0;
end:
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (retvalue < 0)
pq_complete_error(self->conn, &pgres, &error);
return retvalue;
}
RAISES_NEG int
lobject_open(lobjectObject *self, connectionObject *conn,
Oid oid, const char *smode, Oid new_oid, const char *new_file)
{
int retvalue = -1;
PGresult *pgres = NULL;
char *error = NULL;
int pgmode = 0;
int mode;
if (0 > (mode = _lobject_parse_mode(smode))) {
return -1;
}
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
retvalue = pq_begin_locked(self->conn, &pgres, &error, &_save);
if (retvalue < 0)
goto end;
/* if the oid is InvalidOid we create a new lob before opening it
or we import a file from the FS, depending on the value of
new_file */
if (oid == InvalidOid) {
if (new_file)
self->oid = lo_import(self->conn->pgconn, new_file);
else {
/* Use lo_creat when possible to be more middleware-friendly.
See ticket #88. */
if (new_oid != InvalidOid)
self->oid = lo_create(self->conn->pgconn, new_oid);
else
self->oid = lo_creat(self->conn->pgconn, INV_READ | INV_WRITE);
}
Dprintf("lobject_open: large object created with oid = %d",
self->oid);
if (self->oid == InvalidOid) {
collect_error(self->conn, &error);
retvalue = -1;
goto end;
}
mode = (mode & ~LOBJECT_READ) | LOBJECT_WRITE;
}
else {
self->oid = oid;
}
/* if the oid is a real one we try to open with the given mode */
if (mode & LOBJECT_READ) { pgmode |= INV_READ; }
if (mode & LOBJECT_WRITE) { pgmode |= INV_WRITE; }
if (pgmode) {
self->fd = lo_open(self->conn->pgconn, self->oid, pgmode);
Dprintf("lobject_open: large object opened with mode = %i fd = %d",
pgmode, self->fd);
if (self->fd == -1) {
collect_error(self->conn, &error);
retvalue = -1;
goto end;
}
}
/* set the mode for future reference */
self->mode = mode;
Py_BLOCK_THREADS;
self->smode = _lobject_unparse_mode(mode);
Py_UNBLOCK_THREADS;
if (NULL == self->smode) {
retvalue = 1; /* exception already set */
goto end;
}
retvalue = 0;
end:
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (retvalue < 0)
pq_complete_error(self->conn, &pgres, &error);
/* if retvalue > 0, an exception is already set */
return retvalue;
}
