mirror of
https://github.com/subsurface/subsurface.git
synced 2025-01-31 19:33:23 +00:00
Initial implementation of git save format
This saves the dive data into a git object repository instead of a
single XML file.
We create a git object tree with each dive as a separate file,
hierarchically by trip and date.
NOTE 1: This largely duplicates the XML saving code, because trying to
share it seemed just too painful: the logic is very similar, but the
details of the actual strings end up differing sufficiently that there
are tons of trivial differences.
The git save format is line-based with minimal quoting, while XML quotes
everything with either "<..\>" or using single quotes around attributes.
NOTE 2: You currently need a dummy "file" to save to, which points to
the real save location: the git repository and branch to be used. We
should make this a config thing, but for testing, do something like
this:
echo git /home/torvalds/scuba:linus > git-test
to create that git information file, and when you use "Save To" and
specify "git-test" as the file to save to, subsurface will use the new
git save logic to save to the branch "linus" in the repository found at
"/home/torvalds/scuba".
NOTE 3: The git save format uses just the git object directory, it does
*not* check out the result in any git working tree or index. So after
you do a save, you can do
git log -p linus
to see what actually happened in that branch, but it will not affect any
actual checked-out state in the repository.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
This commit is contained in:
Linus Torvalds
Dirk Hohndel
parent
c64227efe0
commit
689fe36030
6 changed files with 744 additions and 29 deletions
24
dive.c
24
dive.c
|
|
@ -224,6 +224,30 @@ void copy_events(struct dive *s, struct dive *d)
|
|||
}
|
||||
}
|
||||
|
||||
int nr_cylinders(struct dive *dive)
|
||||
{
|
||||
int nr;
|
||||
|
||||
for (nr = MAX_CYLINDERS; nr; --nr) {
|
||||
cylinder_t *cylinder = dive->cylinder + nr - 1;
|
||||
if (!cylinder_nodata(cylinder))
|
||||
break;
|
||||
}
|
||||
return nr;
|
||||
}
|
||||
|
||||
int nr_weightsystems(struct dive *dive)
|
||||
{
|
||||
int nr;
|
||||
|
||||
for (nr = MAX_WEIGHTSYSTEMS; nr; --nr) {
|
||||
weightsystem_t *ws = dive->weightsystem + nr - 1;
|
||||
if (!weightsystem_none(ws))
|
||||
break;
|
||||
}
|
||||
return nr;
|
||||
}
|
||||
|
||||
void copy_cylinders(struct dive *s, struct dive *d)
|
||||
{
|
||||
int i;
|
||||
|
|
|
|||
3
dive.h
3
dive.h
|
|
@ -685,6 +685,7 @@ extern void save_dives(const char *filename);
|
|||
extern void save_dives_logic(const char *filename, bool select_only);
|
||||
extern void save_dive(FILE *f, struct dive *dive);
|
||||
extern void export_dives_uddf(const char *filename, const bool selected);
|
||||
extern int git_save_dives(int fd, bool select_only);
|
||||
|
||||
extern int subsurface_rename(const char *path, const char *newpath);
|
||||
extern int subsurface_open(const char *path, int oflags, mode_t mode);
|
||||
|
|
@ -723,6 +724,8 @@ extern void add_gas_switch_event(struct dive *dive, struct divecomputer *dc, int
|
|||
extern void add_event(struct divecomputer *dc, int time, int type, int flags, int value, const char *name);
|
||||
extern void per_cylinder_mean_depth(struct dive *dive, struct divecomputer *dc, int *mean, int *duration);
|
||||
extern int get_cylinder_index(struct dive *dive, struct event *ev);
|
||||
extern int nr_cylinders(struct dive *dive);
|
||||
extern int nr_weightsystems(struct dive *dive);
|
||||
|
||||
/* UI related protopypes */
|
||||
|
||||
|
|
|
|||
689
save-git.c
Normal file
689
save-git.c
Normal file
|
|
@ -0,0 +1,689 @@
|
|||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <errno.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <git2.h>
|
||||
|
||||
#include "dive.h"
|
||||
#include "device.h"
|
||||
#include "membuffer.h"
|
||||
|
||||
#define VA_BUF(b, fmt) do { va_list args; va_start(args, fmt); put_vformat(b, fmt, args); va_end(args); } while (0)
|
||||
|
||||
static void cond_put_format(int cond, struct membuffer *b, const char *fmt, ...)
|
||||
{
|
||||
if (cond) {
|
||||
VA_BUF(b, fmt);
|
||||
}
|
||||
}
|
||||
|
||||
#define SAVE(str, x) cond_put_format(dive->x, b, str " %d\n", dive->x)
|
||||
|
||||
static void put_degrees(struct membuffer *b, degrees_t value, const char sep)
|
||||
{
|
||||
int udeg = value.udeg;
|
||||
const char *sign = "";
|
||||
|
||||
if (udeg < 0) {
|
||||
udeg = -udeg;
|
||||
sign = "-";
|
||||
}
|
||||
put_format(b,"%s%u.%06u%c", sign, FRACTION(udeg, 1000000), sep);
|
||||
}
|
||||
|
||||
static void show_gps(struct membuffer *b, degrees_t latitude, degrees_t longitude)
|
||||
{
|
||||
if (latitude.udeg || longitude.udeg) {
|
||||
put_string(b, "gps ");
|
||||
put_degrees(b, latitude, ' ');
|
||||
put_degrees(b, longitude, '\n');
|
||||
}
|
||||
}
|
||||
|
||||
static void quote(struct membuffer *b, const char *text)
|
||||
{
|
||||
const char *p = text;
|
||||
|
||||
for (;;) {
|
||||
const char *escape;
|
||||
|
||||
switch (*p++) {
|
||||
default:
|
||||
continue;
|
||||
case 0:
|
||||
escape = NULL;
|
||||
break;
|
||||
case 1 ... 8:
|
||||
case 11:
|
||||
case 12:
|
||||
case 14 ... 31:
|
||||
escape = "?";
|
||||
break;
|
||||
case '"':
|
||||
escape = "\\\"";
|
||||
break;
|
||||
case '\n':
|
||||
escape = "\n\t";
|
||||
if (*p == '\n')
|
||||
escape = "\n";
|
||||
break;
|
||||
}
|
||||
put_bytes(b, text, (p - text - 1));
|
||||
if (!escape)
|
||||
break;
|
||||
put_string(b, escape);
|
||||
text = p;
|
||||
}
|
||||
}
|
||||
|
||||
static void show_utf8(struct membuffer *b, const char *prefix, const char *value, const char *postfix)
|
||||
{
|
||||
if (value) {
|
||||
put_format(b, "%s\"", prefix);
|
||||
quote(b, value);
|
||||
put_format(b, "\"%s", postfix);
|
||||
}
|
||||
}
|
||||
|
||||
static void save_overview(struct membuffer *b, struct dive *dive)
|
||||
{
|
||||
show_gps(b, dive->latitude, dive->longitude);
|
||||
show_utf8(b, "location ", dive->location, "\n");
|
||||
show_utf8(b, "divemaster ", dive->divemaster, "\n");
|
||||
show_utf8(b, "buddy ", dive->buddy, "\n");
|
||||
show_utf8(b, "suit ", dive->suit, "\n");
|
||||
show_utf8(b, "notes ", dive->notes, "\n");
|
||||
}
|
||||
|
||||
static void save_tags(struct membuffer *b, struct tag_entry *tags)
|
||||
{
|
||||
const char *sep = " ";
|
||||
|
||||
if (!tags)
|
||||
return;
|
||||
/* The first entry is a dummy, because people don't understand pointers to pointers */
|
||||
tags = tags->next;
|
||||
if (!tags)
|
||||
return;
|
||||
put_string(b, "tags");
|
||||
while (tags) {
|
||||
show_utf8(b, sep, tags->tag->source ? : tags->tag->name, "");
|
||||
sep = ", ";
|
||||
tags = tags->next;
|
||||
}
|
||||
put_string(b, "\n");
|
||||
}
|
||||
|
||||
static void save_cylinder_info(struct membuffer *b, struct dive *dive)
|
||||
{
|
||||
int i, nr;
|
||||
|
||||
nr = nr_cylinders(dive);
|
||||
for (i = 0; i < nr; i++) {
|
||||
cylinder_t *cylinder = dive->cylinder + i;
|
||||
int volume = cylinder->type.size.mliter;
|
||||
const char *description = cylinder->type.description;
|
||||
int o2 = cylinder->gasmix.o2.permille;
|
||||
int he = cylinder->gasmix.he.permille;
|
||||
|
||||
put_string(b, "cylinder");
|
||||
if (volume)
|
||||
put_milli(b, " vol=", volume, "l");
|
||||
put_pressure(b, cylinder->type.workingpressure, " workpressure=", "bar");
|
||||
show_utf8(b, " description=", description, "");
|
||||
strip_mb(b);
|
||||
if (o2) {
|
||||
put_format(b, " o2=%u.%u%%", FRACTION(o2, 10));
|
||||
if (he)
|
||||
put_format(b, " he=%u.%u%%", FRACTION(he, 10));
|
||||
}
|
||||
put_pressure(b, cylinder->start, " start=", "bar");
|
||||
put_pressure(b, cylinder->end, " end=", "bar");
|
||||
put_string(b, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
static void save_weightsystem_info(struct membuffer *b, struct dive *dive)
|
||||
{
|
||||
int i, nr;
|
||||
|
||||
nr = nr_weightsystems(dive);
|
||||
for (i = 0; i < nr; i++) {
|
||||
weightsystem_t *ws = dive->weightsystem + i;
|
||||
int grams = ws->weight.grams;
|
||||
const char *description = ws->description;
|
||||
|
||||
put_string(b, "weightsystem");
|
||||
put_milli(b, " weight=", grams, "kg");
|
||||
show_utf8(b, " description=", description, "");
|
||||
put_string(b, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
static void save_dive_temperature(struct membuffer *b, struct dive *dive)
|
||||
{
|
||||
if (!dive->airtemp.mkelvin && !dive->watertemp.mkelvin)
|
||||
return;
|
||||
if (dive->airtemp.mkelvin == dc_airtemp(&dive->dc) && dive->watertemp.mkelvin == dc_watertemp(&dive->dc))
|
||||
return;
|
||||
|
||||
put_string(b, "divetemperature");
|
||||
if (dive->airtemp.mkelvin != dc_airtemp(&dive->dc))
|
||||
put_temperature(b, dive->airtemp, " air=", "°C");
|
||||
if (dive->watertemp.mkelvin != dc_watertemp(&dive->dc))
|
||||
put_temperature(b, dive->watertemp, " water=", "°C'");
|
||||
put_string(b, "\n");
|
||||
}
|
||||
|
||||
static void save_depths(struct membuffer *b, struct divecomputer *dc)
|
||||
{
|
||||
/* What's the point of this dive entry again? */
|
||||
if (!dc->maxdepth.mm && !dc->meandepth.mm)
|
||||
return;
|
||||
|
||||
put_string(b, " depth");
|
||||
put_depth(b, dc->maxdepth, " max=", "m");
|
||||
put_depth(b, dc->meandepth, " mean=", "m");
|
||||
put_string(b, "\n");
|
||||
}
|
||||
|
||||
static void save_temperatures(struct membuffer *b, struct divecomputer *dc)
|
||||
{
|
||||
if (!dc->airtemp.mkelvin && !dc->watertemp.mkelvin)
|
||||
return;
|
||||
put_string(b, " temperature");
|
||||
put_temperature(b, dc->airtemp, " air=", "°C");
|
||||
put_temperature(b, dc->watertemp, " water=", "°C");
|
||||
put_string(b, "\n");
|
||||
}
|
||||
|
||||
static void save_airpressure(struct membuffer *b, struct divecomputer *dc)
|
||||
{
|
||||
if (!dc->surface_pressure.mbar)
|
||||
return;
|
||||
put_string(b, " surface");
|
||||
put_pressure(b, dc->surface_pressure, " pressure=", "bar");
|
||||
put_string(b, "\n");
|
||||
}
|
||||
|
||||
static void save_salinity(struct membuffer *b, struct divecomputer *dc)
|
||||
{
|
||||
/* only save if we have a value that isn't the default of sea water */
|
||||
if (!dc->salinity || dc->salinity == SEAWATER_SALINITY)
|
||||
return;
|
||||
put_string(b, " water");
|
||||
put_salinity(b, dc->salinity, " salinity=", "g/l");
|
||||
put_string(b, "\n");
|
||||
}
|
||||
|
||||
static void show_date(struct membuffer *b, timestamp_t when)
|
||||
{
|
||||
struct tm tm;
|
||||
|
||||
utc_mkdate(when, &tm);
|
||||
|
||||
put_format(b, " date=%04u-%02u-%02u",
|
||||
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
|
||||
put_format(b, " time=%02u:%02u:%02u",
|
||||
tm.tm_hour, tm.tm_min, tm.tm_sec);
|
||||
}
|
||||
|
||||
static void show_index(struct membuffer *b, int value, const char *pre, const char *post)
|
||||
{
|
||||
if (value)
|
||||
put_format(b, " %s%d%s", pre, value, post);
|
||||
}
|
||||
|
||||
/*
|
||||
* Samples are saved as densely as possible while still being readable,
|
||||
* since they are the bulk of the data.
|
||||
*
|
||||
* For parsing, look at the units to figure out what the numbers are.
|
||||
*/
|
||||
static void save_sample(struct membuffer *b, struct sample *sample, struct sample *old)
|
||||
{
|
||||
put_format(b, " %3u:%02umin", FRACTION(sample->time.seconds, 60));
|
||||
put_milli(b, " ", sample->depth.mm, "m");
|
||||
put_temperature(b, sample->temperature, " ", "°C");
|
||||
put_pressure(b, sample->cylinderpressure, " ", "bar");
|
||||
|
||||
/*
|
||||
* We only show sensor information for samples with pressure, and only if it
|
||||
* changed from the previous sensor we showed.
|
||||
*/
|
||||
if (sample->cylinderpressure.mbar && sample->sensor != old->sensor) {
|
||||
put_format(b, " sensor=%d", sample->sensor);
|
||||
old->sensor = sample->sensor;
|
||||
}
|
||||
|
||||
/* the deco/ndl values are stored whenever they change */
|
||||
if (sample->ndl.seconds != old->ndl.seconds) {
|
||||
put_format(b, " ndl=%u:%02umin", FRACTION(sample->ndl.seconds, 60));
|
||||
old->ndl = sample->ndl;
|
||||
}
|
||||
if (sample->in_deco != old->in_deco) {
|
||||
put_format(b, " in_deco=%d", sample->in_deco ? 1 : 0);
|
||||
old->in_deco = sample->in_deco;
|
||||
}
|
||||
if (sample->stoptime.seconds != old->stoptime.seconds) {
|
||||
put_format(b, " stoptime=%u:%02umin", FRACTION(sample->stoptime.seconds, 60));
|
||||
old->stoptime = sample->stoptime;
|
||||
}
|
||||
|
||||
if (sample->stopdepth.mm != old->stopdepth.mm) {
|
||||
put_milli(b, " stopdepth=", sample->stopdepth.mm, "m");
|
||||
old->stopdepth = sample->stopdepth;
|
||||
}
|
||||
|
||||
if (sample->cns != old->cns) {
|
||||
put_format(b, " cns=%u%%", sample->cns);
|
||||
old->cns = sample->cns;
|
||||
}
|
||||
|
||||
if (sample->po2 != old->po2) {
|
||||
put_milli(b, " po2=", sample->po2, "bar");
|
||||
old->po2 = sample->po2;
|
||||
}
|
||||
show_index(b, sample->heartbeat, "heartbeat=", "");
|
||||
show_index(b, sample->bearing, "bearing=", "°");
|
||||
put_format(b, "\n");
|
||||
}
|
||||
|
||||
static void save_samples(struct membuffer *b, int nr, struct sample *s)
|
||||
{
|
||||
struct sample dummy = {};
|
||||
|
||||
while (--nr >= 0) {
|
||||
save_sample(b, s, &dummy);
|
||||
s++;
|
||||
}
|
||||
}
|
||||
|
||||
static void save_one_event(struct membuffer *b, struct event *ev)
|
||||
{
|
||||
put_format(b, " event %d:%02dmin", FRACTION(ev->time.seconds, 60));
|
||||
show_index(b, ev->type, "type=", "");
|
||||
show_index(b, ev->flags, "flags=", "");
|
||||
show_index(b, ev->value, "value=", "");
|
||||
show_utf8(b, ev->name, " name=", "");
|
||||
put_string(b, "\n");
|
||||
}
|
||||
|
||||
static void save_events(struct membuffer *b, struct event *ev)
|
||||
{
|
||||
while (ev) {
|
||||
save_one_event(b, ev);
|
||||
ev = ev->next;
|
||||
}
|
||||
}
|
||||
|
||||
static void save_dc(struct membuffer *b, struct dive *dive, struct divecomputer *dc)
|
||||
{
|
||||
put_format(b, "divecomputer");
|
||||
show_utf8(b, " model=", dc->model, "");
|
||||
if (dc->deviceid)
|
||||
put_format(b, " deviceid=%08x", dc->deviceid);
|
||||
if (dc->diveid)
|
||||
put_format(b, " diveid=%08x", dc->diveid);
|
||||
if (dc->when && dc->when != dive->when)
|
||||
show_date(b, dc->when);
|
||||
if (dc->duration.seconds && dc->duration.seconds != dive->dc.duration.seconds)
|
||||
put_duration(b, dc->duration, " duration=", "min");
|
||||
put_string(b, "\n");
|
||||
|
||||
save_depths(b, dc);
|
||||
save_temperatures(b, dc);
|
||||
save_airpressure(b, dc);
|
||||
save_salinity(b, dc);
|
||||
put_duration(b, dc->surfacetime, " surfacetime", "min\n");
|
||||
|
||||
save_events(b, dc->events);
|
||||
save_samples(b, dc->samples, dc->sample);
|
||||
}
|
||||
|
||||
/*
|
||||
* Note that we don't save the date and time or dive
|
||||
* number: they are encoded in the filename.
|
||||
*/
|
||||
static void create_dive_buffer(struct dive *dive, struct membuffer *b)
|
||||
{
|
||||
struct divecomputer *dc;
|
||||
|
||||
put_format(b, "duration %u:%02u min\n", FRACTION(dive->dc.duration.seconds, 60));
|
||||
SAVE("rating", rating);
|
||||
SAVE("visibility", visibility);
|
||||
cond_put_format(dive->tripflag == NO_TRIP, b, "notrip\n");
|
||||
save_tags(b, dive->tag_list);
|
||||
|
||||
save_overview(b, dive);
|
||||
save_cylinder_info(b, dive);
|
||||
save_weightsystem_info(b, dive);
|
||||
save_dive_temperature(b, dive);
|
||||
|
||||
/* Save the dive computer data */
|
||||
dc = &dive->dc;
|
||||
do {
|
||||
save_dc(b, dive, dc);
|
||||
dc = dc->next;
|
||||
} while (dc);
|
||||
}
|
||||
|
||||
static int git_save_error(const char *fmt, ...)
|
||||
{
|
||||
struct membuffer b = { 0 };
|
||||
VA_BUF(&b, fmt);
|
||||
|
||||
/* We should do some UI element thing describing the failure */
|
||||
put_bytes(&b, "\n", 1);
|
||||
flush_buffer(&b, stderr);
|
||||
free_buffer(&b);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* libgit2 has a "git_treebuilder" concept, but it's broken, and can not
|
||||
* be used to do a flat tree (like the git "index") nor a recursive tree.
|
||||
* Stupid.
|
||||
*
|
||||
* So we have to do that "keep track of recursive treebuilder entries"
|
||||
* ourselves. We use 'git_treebuilder' for any regular files, and our own
|
||||
* data structures for recursive trees.
|
||||
*
|
||||
* When finally writing it out, we traverse the subdirectories depth-
|
||||
* first, writing them out, and then adding the written-out trees to
|
||||
* the git_treebuilder they existed in.
|
||||
*/
|
||||
struct dir {
|
||||
git_treebuilder *files;
|
||||
struct dir *subdirs, *sibling;
|
||||
char name[1];
|
||||
};
|
||||
|
||||
/*
|
||||
* The name of a dive is the date plus a hash of the contents.
|
||||
*/
|
||||
static void generate_name(struct dive *dive, git_oid *id, struct membuffer *name)
|
||||
{
|
||||
struct tm tm;
|
||||
|
||||
utc_mkdate(dive->when, &tm);
|
||||
put_format(name, "%04u-%02u-%02u-%02u:%02u:%02u",
|
||||
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
|
||||
tm.tm_hour, tm.tm_min, tm.tm_sec);
|
||||
cond_put_format(dive->number, name, "-%d", dive->number);
|
||||
put_format(name, "-%02x%02x%02x%02x%c",
|
||||
id->id[0], id->id[1], id->id[2], id->id[3], 0);
|
||||
}
|
||||
|
||||
static int save_one_dive(git_repository *repo, struct dir *tree, struct dive *dive)
|
||||
{
|
||||
struct membuffer buf = { 0 }, name = { 0 };
|
||||
git_oid blob_id;
|
||||
int ret;
|
||||
|
||||
create_dive_buffer(dive, &buf);
|
||||
ret = git_blob_create_frombuffer(&blob_id, repo, buf.buffer, buf.len);
|
||||
free_buffer(&buf);
|
||||
if (ret)
|
||||
return git_save_error("git blob creation failed");
|
||||
|
||||
generate_name(dive, &blob_id, &name);
|
||||
ret = git_treebuilder_insert(NULL, tree->files, name.buffer, &blob_id, 0100644);
|
||||
free_buffer(&name);
|
||||
if (ret)
|
||||
return git_save_error("git tree insert failed");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* This does *not* make sure the new subdirectory doesn't
|
||||
* alias some existing name. Currently we always create
|
||||
* unique subdirectory names ("tripXYZ"), but ..
|
||||
*/
|
||||
static struct dir *new_directory(struct dir *parent, const char *fmt, ...)
|
||||
{
|
||||
struct membuffer name = { 0 };
|
||||
struct dir *subdir;
|
||||
|
||||
VA_BUF(&name, fmt);
|
||||
subdir = malloc(sizeof(*subdir)+name.len);
|
||||
|
||||
/*
|
||||
* It starts out empty: no subdirectories of its own,
|
||||
* and an empty treebuilder list of files.
|
||||
*/
|
||||
subdir->subdirs = NULL;
|
||||
git_treebuilder_create(&subdir->files, NULL);
|
||||
memcpy(subdir->name, name.buffer, name.len);
|
||||
subdir->name[name.len] = 0;
|
||||
|
||||
/* Add it to the list of subdirs of the parent */
|
||||
subdir->sibling = parent->subdirs;
|
||||
parent->subdirs = subdir;
|
||||
|
||||
return subdir;
|
||||
}
|
||||
|
||||
static int save_one_trip(git_repository *repo, struct dir *tree, dive_trip_t *trip, int idx)
|
||||
{
|
||||
int i;
|
||||
struct dive *dive;
|
||||
struct dir *subdir;
|
||||
|
||||
subdir = new_directory(tree, "trip%03d", idx);
|
||||
for_each_dive(i, dive) {
|
||||
if (dive->divetrip == trip)
|
||||
save_one_dive(repo, subdir, dive);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define TRIPNAME_SIZE (10)
|
||||
|
||||
static int create_git_tree(git_repository *repo, struct dir *tree, bool select_only)
|
||||
{
|
||||
int i, tripidx;
|
||||
struct dive *dive;
|
||||
dive_trip_t *trip;
|
||||
|
||||
tripidx = 0;
|
||||
for (trip = dive_trip_list; trip != NULL; trip = trip->next)
|
||||
trip->index = 0;
|
||||
|
||||
/* save the dives */
|
||||
for_each_dive(i, dive) {
|
||||
trip = dive->divetrip;
|
||||
|
||||
if (select_only) {
|
||||
if (!dive->selected)
|
||||
continue;
|
||||
/* We don't save trips when doing selected dive saves */
|
||||
trip = NULL;
|
||||
}
|
||||
|
||||
if (trip) {
|
||||
/* Did we already save this trip? */
|
||||
if (trip->index)
|
||||
continue;
|
||||
trip->index = ++tripidx;
|
||||
|
||||
/* Pass that new subdirectory in for save-trip */
|
||||
save_one_trip(repo, tree, trip, tripidx);
|
||||
continue;
|
||||
}
|
||||
|
||||
save_one_dive(repo, tree, dive);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* libgit2 revision 0.19 and earlier do not have the signature and
|
||||
* message log arguments.
|
||||
*/
|
||||
#if !LIBGIT2_VER_MAJOR && LIBGIT2_VER_MINOR <= 19
|
||||
#define git_branch_create(out,repo,branch_name,target,force,sig,msg) \
|
||||
git_branch_create(out,repo,branch_name,target,force)
|
||||
#define git_reference_set_target(out,ref,target,signature,log_message) \
|
||||
git_reference_set_target(out,ref,target)
|
||||
#endif
|
||||
|
||||
static int create_new_commit(git_repository *repo, const char *branch, git_oid *tree_id)
|
||||
{
|
||||
int ret;
|
||||
git_reference *ref;
|
||||
git_object *parent;
|
||||
git_oid commit_id;
|
||||
git_signature *author;
|
||||
git_commit *commit;
|
||||
git_tree *tree;
|
||||
|
||||
ret = git_branch_lookup(&ref, repo, branch, GIT_BRANCH_LOCAL);
|
||||
switch (ret) {
|
||||
default:
|
||||
return git_save_error("Bad branch '%s' (%s)", branch, strerror(errno));
|
||||
case GIT_EINVALIDSPEC:
|
||||
return git_save_error("Invalid branch name '%s'", branch);
|
||||
case GIT_ENOTFOUND: /* We'll happily create it */
|
||||
ref = NULL; parent = NULL;
|
||||
break;
|
||||
case 0:
|
||||
if (git_reference_peel(&parent, ref, GIT_OBJ_COMMIT))
|
||||
return git_save_error("Unable to look up parent in branch '%s'", branch);
|
||||
/* all good */
|
||||
break;
|
||||
}
|
||||
|
||||
if (git_tree_lookup(&tree, repo, tree_id))
|
||||
return git_save_error("Could not look up newly created tree");
|
||||
|
||||
/* git_signature_default() is too recent */
|
||||
if (git_signature_now(&author, "Subsurface", "subsurface@hohndel.org"))
|
||||
return git_save_error("No user name configuration in git repo");
|
||||
|
||||
if (git_commit_create_v(&commit_id, repo, NULL, author, author, NULL, "subsurface commit", tree, parent != NULL, parent))
|
||||
return git_save_error("Git commit create failed (%s)", strerror(errno));
|
||||
|
||||
if (git_commit_lookup(&commit, repo, &commit_id))
|
||||
return git_save_error("Could not look up newly created commit");
|
||||
|
||||
if (!ref) {
|
||||
if (git_branch_create(&ref, repo, branch, commit, 0, author, "Create branch"))
|
||||
return git_save_error("Failed to create branch '%s'", branch);
|
||||
}
|
||||
if (git_reference_set_target(&ref, ref, &commit_id, author, "Subsurface save event"))
|
||||
return git_save_error("Failed to update branch '%s'", branch);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int write_git_tree(git_repository *repo, struct dir *tree, git_oid *result)
|
||||
{
|
||||
int ret;
|
||||
struct dir *subdir;
|
||||
|
||||
/* Write out our subdirectories, add them to the treebuilder, and free them */
|
||||
while ((subdir = tree->subdirs) != NULL) {
|
||||
git_oid id;
|
||||
|
||||
if (!write_git_tree(repo, subdir, &id))
|
||||
git_treebuilder_insert(NULL, tree->files, subdir->name, &id, 0040000);
|
||||
tree->subdirs = subdir->sibling;
|
||||
free(subdir);
|
||||
};
|
||||
|
||||
/* .. write out the resulting treebuilder */
|
||||
ret = git_treebuilder_write(result, repo, tree->files);
|
||||
|
||||
/* .. and free the now useless treebuilder */
|
||||
git_treebuilder_free(tree->files);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int do_git_save(git_repository *repo, const char *branch, bool select_only)
|
||||
{
|
||||
struct dir tree;
|
||||
git_oid id;
|
||||
|
||||
/* Start with an empty tree: no subdirectories, no files */
|
||||
tree.name[0] = 0;
|
||||
tree.subdirs = NULL;
|
||||
if (git_treebuilder_create(&tree.files, NULL))
|
||||
return git_save_error("git treebuilder failed");
|
||||
|
||||
/* Populate our tree data structure */
|
||||
if (create_git_tree(repo, &tree, select_only))
|
||||
return -1;
|
||||
|
||||
if (write_git_tree(repo, &tree, &id))
|
||||
return git_save_error("git tree write failed");
|
||||
|
||||
/* And save the tree! */
|
||||
create_new_commit(repo, branch, &id);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int git_save_dives(int fd, bool select_only)
|
||||
{
|
||||
int len, ret;
|
||||
struct stat st;
|
||||
static char buffer[2048];
|
||||
git_repository *repo;
|
||||
char *loc, *branch;
|
||||
|
||||
if (fstat(fd, &st) < 0)
|
||||
return 0;
|
||||
if (st.st_size >= sizeof(buffer))
|
||||
return 0;
|
||||
len = st.st_size;
|
||||
if (read(fd, buffer, len) != len)
|
||||
return 0;
|
||||
buffer[len] = 0;
|
||||
if (len < 4)
|
||||
return 0;
|
||||
if (memcmp(buffer, "git ", 4))
|
||||
return 0;
|
||||
|
||||
/* Ok, it's a git pointer, we're going to follow it */
|
||||
close(fd);
|
||||
|
||||
/* Trim any whitespace at the end */
|
||||
while (isspace(buffer[len-1]))
|
||||
buffer[--len] = 0;
|
||||
|
||||
/* skip the "git" part and any whitespace from the beginning */
|
||||
loc = buffer+3;
|
||||
len -= 3;
|
||||
while (isspace(*loc)) {
|
||||
loc++;
|
||||
len--;
|
||||
}
|
||||
|
||||
if (!len)
|
||||
return git_save_error("Invalid git pointer");
|
||||
|
||||
/*
|
||||
* The result should be a git directory and branch name, like
|
||||
* "/home/torvalds/scuba:linus"
|
||||
*/
|
||||
branch = strrchr(loc, ':');
|
||||
if (branch)
|
||||
*branch++ = 0;
|
||||
|
||||
if (git_repository_open(&repo, loc))
|
||||
return git_save_error("Unable to open git repository at '%s' (branch '%s')", loc, branch);
|
||||
|
||||
ret = do_git_save(repo, branch, select_only);
|
||||
git_repository_free(repo);
|
||||
return ret < 0 ? ret : 1;
|
||||
}
|
||||
54
save-xml.c
54
save-xml.c
|
|
@ -5,6 +5,7 @@
|
|||
#include <errno.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#include "dive.h"
|
||||
#include "device.h"
|
||||
|
|
@ -210,18 +211,6 @@ static void save_overview(struct membuffer *b, struct dive *dive)
|
|||
show_utf8(b, dive->suit, " <suit>", "</suit>\n", 0);
|
||||
}
|
||||
|
||||
static int nr_cylinders(struct dive *dive)
|
||||
{
|
||||
int nr;
|
||||
|
||||
for (nr = MAX_CYLINDERS; nr; --nr) {
|
||||
cylinder_t *cylinder = dive->cylinder + nr - 1;
|
||||
if (!cylinder_nodata(cylinder))
|
||||
break;
|
||||
}
|
||||
return nr;
|
||||
}
|
||||
|
||||
static void save_cylinder_info(struct membuffer *b, struct dive *dive)
|
||||
{
|
||||
int i, nr;
|
||||
|
|
@ -251,18 +240,6 @@ static void save_cylinder_info(struct membuffer *b, struct dive *dive)
|
|||
}
|
||||
}
|
||||
|
||||
static int nr_weightsystems(struct dive *dive)
|
||||
{
|
||||
int nr;
|
||||
|
||||
for (nr = MAX_WEIGHTSYSTEMS; nr; --nr) {
|
||||
weightsystem_t *ws = dive->weightsystem + nr - 1;
|
||||
if (!weightsystem_none(ws))
|
||||
break;
|
||||
}
|
||||
return nr;
|
||||
}
|
||||
|
||||
static void save_weightsystem_info(struct membuffer *b, struct dive *dive)
|
||||
{
|
||||
int i, nr;
|
||||
|
|
@ -609,15 +586,12 @@ static void save_backup(const char *name, const char *ext, const char *new_ext)
|
|||
free(newname);
|
||||
}
|
||||
|
||||
void save_dives_logic(const char *filename, const bool select_only)
|
||||
static void try_to_backup(const char *filename)
|
||||
{
|
||||
struct membuffer buf = { 0 };
|
||||
FILE *f;
|
||||
char extension[][5] = { "xml", "ssrf", "" };
|
||||
int i = 0;
|
||||
int flen = strlen(filename);
|
||||
|
||||
save_dives_buffer(&buf, select_only);
|
||||
/* Maybe we might want to make this configurable? */
|
||||
while (extension[i][0] != '\0') {
|
||||
int elen = strlen(extension[i]);
|
||||
|
|
@ -627,6 +601,30 @@ void save_dives_logic(const char *filename, const bool select_only)
|
|||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
void save_dives_logic(const char *filename, const bool select_only)
|
||||
{
|
||||
struct membuffer buf = { 0 };
|
||||
FILE *f;
|
||||
int fd;
|
||||
|
||||
/*
|
||||
* See if the file already exists, and if so,
|
||||
* perhaps it's a git save-file pointer?
|
||||
*
|
||||
* Otherwise, try to back it up.
|
||||
*/
|
||||
fd = subsurface_open(filename, O_RDONLY, 0);
|
||||
if (fd >= 0) {
|
||||
if (git_save_dives(fd, select_only))
|
||||
return;
|
||||
close(fd);
|
||||
try_to_backup(filename);
|
||||
}
|
||||
|
||||
save_dives_buffer(&buf, select_only);
|
||||
|
||||
f = subsurface_fopen(filename, "w");
|
||||
if (f) {
|
||||
flush_buffer(&buf, f);
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ LIBS *= $$XSLT_LIBS $$XML2_LIBS
|
|||
# We're searching for:
|
||||
# libzip
|
||||
# sqlite3
|
||||
link_pkgconfig: PKGCONFIG += libzip sqlite3
|
||||
link_pkgconfig: PKGCONFIG += libzip sqlite3 libgit2
|
||||
|
||||
# Add libiconv if needed
|
||||
link_pkgconfig: packagesExist(libiconv): PKGCONFIG += libiconv
|
||||
|
|
|
|||
|
|
@ -115,6 +115,7 @@ SOURCES = \
|
|||
qt-ui/subsurfacewebservices.cpp \
|
||||
qt-ui/tableview.cpp \
|
||||
qt-ui/exif.cpp \
|
||||
save-git.c \
|
||||
save-xml.c \
|
||||
sha1.c \
|
||||
statistics.c \
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue