int
seaf_quota_manager_set_org_user_quota (SeafQuotaManager *mgr,
int org_id,
const char *user,
gint64 quota)
{
SeafDB *db = mgr->session->db;
char sql[512];
if (seaf_db_type(db) == SEAF_DB_TYPE_PGSQL) {
gboolean err;
snprintf(sql, sizeof(sql),
"SELECT 1 FROM OrgUserQuota WHERE org_id=%d AND user='******'",
org_id, user);
if (seaf_db_check_for_existence(db, sql, &err))
snprintf(sql, sizeof(sql),
"UPDATE OrgUserQuota SET quota=%"G_GINT64_FORMAT
" WHERE org_id=%d AND user='******'", quota, org_id, user);
else
snprintf(sql, sizeof(sql),
"INSERT INTO OrgQuota VALUES "
"(%d, '%s', %"G_GINT64_FORMAT")", org_id, user, quota);
if (err)
return -1;
return seaf_db_query (db, sql);
} else {
snprintf (sql, sizeof(sql),
"REPLACE INTO OrgUserQuota VALUES ('%d', '%s', %"G_GINT64_FORMAT")",
org_id, user, quota);
return seaf_db_query (mgr->session->db, sql);
}
}
int
seaf_share_manager_start (SeafShareManager *mgr)
{
SeafDB *db = mgr->seaf->db;
const char *sql;
int db_type = seaf_db_type (db);
if (db_type == SEAF_DB_TYPE_MYSQL) {
sql = "CREATE TABLE IF NOT EXISTS SharedRepo "
"(repo_id CHAR(37) , from_email VARCHAR(512), to_email VARCHAR(512), "
"permission CHAR(15), INDEX (repo_id))";
if (seaf_db_query (db, sql) < 0)
return -1;
} else if (db_type == SEAF_DB_TYPE_SQLITE) {
sql = "CREATE TABLE IF NOT EXISTS SharedRepo "
"(repo_id CHAR(37) , from_email VARCHAR(512), to_email VARCHAR(512), "
"permission CHAR(15))";
if (seaf_db_query (db, sql) < 0)
return -1;
sql = "CREATE INDEX IF NOT EXISTS RepoIdIndex on SharedRepo (repo_id)";
if (seaf_db_query (db, sql) < 0)
return -1;
}
return 0;
}
int
seaf_repo_manager_set_repo_valid_since (SeafRepoManager *mgr,
const char *repo_id,
gint64 timestamp)
{
SeafDB *db = mgr->seaf->db;
char sql[256];
if (seaf_db_type(db) == SEAF_DB_TYPE_PGSQL) {
gboolean err;
snprintf(sql, sizeof(sql),
"SELECT repo_id FROM RepoValidSince WHERE "
"repo_id='%s'", repo_id);
if (seaf_db_check_for_existence(db, sql, &err))
snprintf(sql, sizeof(sql),
"UPDATE RepoValidSince SET timestamp=%"G_GINT64_FORMAT
" WHERE repo_id='%s'", timestamp, repo_id);
else
snprintf(sql, sizeof(sql),
"INSERT INTO RepoValidSince VALUES "
"('%s', %"G_GINT64_FORMAT")", repo_id, timestamp);
if (err)
return -1;
if (seaf_db_query (db, sql) < 0)
return -1;
} else {
snprintf (sql, sizeof(sql),
"REPLACE INTO RepoValidSince VALUES ('%s', %"G_GINT64_FORMAT")",
repo_id, timestamp);
if (seaf_db_query (db, sql) < 0)
return -1;
}
return 0;
}
static int
open_db (SeafBranchManager *mgr)
{
#ifndef SEAFILE_SERVER
char *db_path;
const char *sql;
db_path = g_build_filename (mgr->seaf->seaf_dir, BRANCH_DB, NULL);
if (sqlite_open_db (db_path, &mgr->priv->db) < 0) {
g_critical ("[Branch mgr] Failed to open branch db\n");
g_free (db_path);
return -1;
}
g_free (db_path);
sql = "CREATE TABLE IF NOT EXISTS Branch ("
"name TEXT, repo_id TEXT, commit_id TEXT);";
if (sqlite_query_exec (mgr->priv->db, sql) < 0)
return -1;
sql = "CREATE INDEX IF NOT EXISTS branch_index ON Branch(repo_id, name);";
if (sqlite_query_exec (mgr->priv->db, sql) < 0)
return -1;
#elif defined FULL_FEATURE
char *sql;
switch (seaf_db_type (mgr->seaf->db)) {
case SEAF_DB_TYPE_MYSQL:
sql = "CREATE TABLE IF NOT EXISTS Branch ("
"name VARCHAR(10), repo_id CHAR(41), commit_id CHAR(41),"
"PRIMARY KEY (repo_id, name)) ENGINE = INNODB";
if (seaf_db_query (mgr->seaf->db, sql) < 0)
return -1;
break;
case SEAF_DB_TYPE_PGSQL:
sql = "CREATE TABLE IF NOT EXISTS Branch ("
"name VARCHAR(10), repo_id CHAR(40), commit_id CHAR(40),"
"PRIMARY KEY (repo_id, name))";
if (seaf_db_query (mgr->seaf->db, sql) < 0)
return -1;
break;
case SEAF_DB_TYPE_SQLITE:
sql = "CREATE TABLE IF NOT EXISTS Branch ("
"name VARCHAR(10), repo_id CHAR(41), commit_id CHAR(41),"
"PRIMARY KEY (repo_id, name))";
if (seaf_db_query (mgr->seaf->db, sql) < 0)
return -1;
break;
}
#endif
return 0;
}
int
seaf_share_manager_start (SeafShareManager *mgr)
{
SeafDB *db = mgr->seaf->db;
const char *sql;
int db_type = seaf_db_type (db);
if (db_type == SEAF_DB_TYPE_MYSQL) {
sql = "CREATE TABLE IF NOT EXISTS SharedRepo "
"(id INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT,"
"repo_id CHAR(37) , from_email VARCHAR(255), to_email VARCHAR(255), "
"permission CHAR(15), INDEX (repo_id), "
"INDEX(from_email), INDEX(to_email)) ENGINE=INNODB";
if (seaf_db_query (db, sql) < 0)
return -1;
} else if (db_type == SEAF_DB_TYPE_SQLITE) {
sql = "CREATE TABLE IF NOT EXISTS SharedRepo "
"(repo_id CHAR(37) , from_email VARCHAR(255), to_email VARCHAR(255), "
"permission CHAR(15))";
if (seaf_db_query (db, sql) < 0)
return -1;
sql = "CREATE INDEX IF NOT EXISTS RepoIdIndex on SharedRepo (repo_id)";
if (seaf_db_query (db, sql) < 0)
return -1;
sql = "CREATE INDEX IF NOT EXISTS FromEmailIndex on SharedRepo (from_email)";
if (seaf_db_query (db, sql) < 0)
return -1;
sql = "CREATE INDEX IF NOT EXISTS ToEmailIndex on SharedRepo (to_email)";
if (seaf_db_query (db, sql) < 0)
return -1;
} else if (db_type == SEAF_DB_TYPE_PGSQL) {
sql = "CREATE TABLE IF NOT EXISTS SharedRepo "
"(repo_id CHAR(36) , from_email VARCHAR(255), to_email VARCHAR(255), "
"permission VARCHAR(15))";
if (seaf_db_query (db, sql) < 0)
return -1;
if (!pgsql_index_exists (db, "sharedrepo_repoid_idx")) {
sql = "CREATE INDEX sharedrepo_repoid_idx ON SharedRepo (repo_id)";
if (seaf_db_query (db, sql) < 0)
return -1;
}
if (!pgsql_index_exists (db, "sharedrepo_from_email_idx")) {
sql = "CREATE INDEX sharedrepo_from_email_idx ON SharedRepo (from_email)";
if (seaf_db_query (db, sql) < 0)
return -1;
}
if (!pgsql_index_exists (db, "sharedrepo_to_email_idx")) {
sql = "CREATE INDEX sharedrepo_to_email_idx ON SharedRepo (to_email)";
if (seaf_db_query (db, sql) < 0)
return -1;
}
}
return 0;
}
static int
open_db (SeafBranchManager *mgr)
{
#ifndef SEAFILE_SERVER
char *db_path;
const char *sql;
db_path = g_build_filename (mgr->seaf->seaf_dir, BRANCH_DB, NULL);
if (sqlite_open_db (db_path, &mgr->priv->db) < 0) {
g_critical ("[Branch mgr] Failed to open branch db\n");
g_free (db_path);
return -1;
}
g_free (db_path);
sql = "CREATE TABLE IF NOT EXISTS Branch ("
"name TEXT, repo_id TEXT, commit_id TEXT);";
if (sqlite_query_exec (mgr->priv->db, sql) < 0)
return -1;
sql = "CREATE INDEX IF NOT EXISTS branch_index ON Branch(repo_id, name);";
if (sqlite_query_exec (mgr->priv->db, sql) < 0)
return -1;
#else
char *sql = "CREATE TABLE IF NOT EXISTS Branch ("
"name VARCHAR(10), repo_id CHAR(41), commit_id CHAR(41),"
"PRIMARY KEY (repo_id, name))";
if (seaf_db_query (mgr->seaf->db, sql) < 0)
return -1;
#endif
return 0;
}
int
seaf_share_manager_add_share (SeafShareManager *mgr, const char *repo_id,
const char *from_email, const char *to_email,
const char *permission)
{
char sql[512];
gboolean db_err = FALSE;
int ret = 0;
char *from_email_l = g_ascii_strdown (from_email, -1);
char *to_email_l = g_ascii_strdown (to_email, -1);
snprintf (sql, sizeof(sql),
"SELECT repo_id from SharedRepo WHERE repo_id='%s' AND "
"from_email='%s' AND to_email='%s'", repo_id, from_email_l,
to_email_l);
if (seaf_db_check_for_existence (mgr->seaf->db, sql, &db_err))
goto out;
snprintf (sql, sizeof(sql),
"INSERT INTO SharedRepo VALUES ('%s', '%s', '%s', '%s')", repo_id,
from_email_l, to_email_l, permission);
if (seaf_db_query (mgr->seaf->db, sql) < 0) {
ret = -1;
goto out;
}
out:
g_free (from_email_l);
g_free (to_email_l);
return ret;
}
int
seaf_branch_manager_update_branch (SeafBranchManager *mgr, SeafBranch *branch)
{
#ifndef SEAFILE_SERVER
sqlite3 *db;
char *sql;
pthread_mutex_lock (&mgr->priv->db_lock);
db = mgr->priv->db;
sql = sqlite3_mprintf ("UPDATE Branch SET commit_id = %Q "
"WHERE name = %Q AND repo_id = %Q",
branch->commit_id, branch->name, branch->repo_id);
sqlite_query_exec (db, sql);
sqlite3_free (sql);
pthread_mutex_unlock (&mgr->priv->db_lock);
return 0;
#else
char sql[256];
snprintf (sql, sizeof(sql),
"UPDATE Branch SET commit_id = '%s' "
"WHERE name = '%s' AND repo_id = '%s'",
branch->commit_id, branch->name, branch->repo_id);
if (seaf_db_query (mgr->seaf->db, sql) < 0)
return -1;
return 0;
#endif
}
int
seaf_branch_manager_del_branch (SeafBranchManager *mgr,
const char *repo_id,
const char *name)
{
#ifndef SEAFILE_SERVER
char *sql;
pthread_mutex_lock (&mgr->priv->db_lock);
sql = sqlite3_mprintf ("DELETE FROM Branch WHERE name = %Q AND "
"repo_id = '%s'", name, repo_id);
if (sqlite_query_exec (mgr->priv->db, sql) < 0)
g_warning ("Delete branch %s failed\n", name);
sqlite3_free (sql);
pthread_mutex_unlock (&mgr->priv->db_lock);
return 0;
#else
char sql[256];
snprintf (sql, sizeof(sql),
"DELETE FROM Branch WHERE name = '%s' AND repo_id = '%s'",
name, repo_id);
if (seaf_db_query (mgr->seaf->db, sql) < 0)
return -1;
return 0;
#endif
}
int
seaf_branch_manager_add_branch (SeafBranchManager *mgr, SeafBranch *branch)
{
#ifndef SEAFILE_SERVER
char *sql;
pthread_mutex_lock (&mgr->priv->db_lock);
sql = sqlite3_mprintf ("INSERT INTO Branch VALUES (%Q, %Q, %Q)",
branch->name, branch->repo_id, branch->commit_id);
sqlite_query_exec (mgr->priv->db, sql);
sqlite3_free (sql);
pthread_mutex_unlock (&mgr->priv->db_lock);
return 0;
#else
char sql[256];
snprintf (sql, sizeof(sql), "REPLACE INTO Branch VALUES ('%s', '%s', '%s')",
branch->name, branch->repo_id, branch->commit_id);
if (seaf_db_query (mgr->seaf->db, sql) < 0)
return -1;
return 0;
#endif
}
int
set_system_default_repo_id (SeafileSession *session, const char *repo_id)
{
char sql[256];
snprintf (sql, sizeof(sql),
"INSERT INTO SystemInfo VALUES ('default_repo_id', '%s')",
repo_id);
return seaf_db_query (session->db, sql);
}
void
seaf_repo_manager_remove_garbage_repo (SeafRepoManager *mgr, const char *repo_id)
{
char sql[256];
snprintf (sql, sizeof(sql), "DELETE FROM GarbageRepos WHERE repo_id='%s'",
repo_id);
seaf_db_query (seaf->db, sql);
}
int
seaf_repo_manager_set_repo_history_limit (SeafRepoManager *mgr,
const char *repo_id,
int days)
{
SeafVirtRepo *vinfo;
SeafDB *db = mgr->seaf->db;
char sql[256];
vinfo = seaf_repo_manager_get_virtual_repo_info (mgr, repo_id);
if (vinfo) {
seaf_virtual_repo_info_free (vinfo);
return 0;
}
if (seaf_db_type(db) == SEAF_DB_TYPE_PGSQL) {
gboolean err;
snprintf(sql, sizeof(sql),
"SELECT repo_id FROM RepoHistoryLimit "
"WHERE repo_id='%s'", repo_id);
if (seaf_db_check_for_existence(db, sql, &err))
snprintf(sql, sizeof(sql),
"UPDATE RepoHistoryLimit SET days=%d"
"WHERE repo_id='%s'", days, repo_id);
else
snprintf(sql, sizeof(sql),
"INSERT INTO RepoHistoryLimit VALUES "
"('%s', %d)", repo_id, days);
if (err)
return -1;
return seaf_db_query(db, sql);
} else {
snprintf (sql, sizeof(sql),
"REPLACE INTO RepoHistoryLimit VALUES ('%s', %d)",
repo_id, days);
if (seaf_db_query (db, sql) < 0)
return -1;
}
return 0;
}
int
seaf_quota_manager_set_org_quota (SeafQuotaManager *mgr,
int org_id,
gint64 quota)
{
char sql[512];
snprintf (sql, sizeof(sql),
"REPLACE INTO OrgQuota VALUES ('%d', %"G_GINT64_FORMAT")",
org_id, quota);
return seaf_db_query (mgr->session->db, sql);
}
int
seaf_quota_manager_set_user_quota (SeafQuotaManager *mgr,
const char *user,
gint64 quota)
{
char sql[512];
snprintf (sql, sizeof(sql),
"REPLACE INTO UserQuota VALUES ('%s', %"G_GINT64_FORMAT")",
user, quota);
return seaf_db_query (mgr->session->db, sql);
}
void
schedule_create_system_default_repo (SeafileSession *session)
{
char *sql = "CREATE TABLE IF NOT EXISTS SystemInfo "
"(info_key VARCHAR(256), info_value VARCHAR(1024))";
if (seaf_db_query (session->db, sql) < 0)
return;
ccnet_job_manager_schedule_job (session->job_mgr,
create_system_default_repo,
NULL, session);
}
int
seaf_share_manager_set_permission (SeafShareManager *mgr, const char *repo_id,
const char *from_email, const char *to_email,
const char *permission)
{
char sql[512];
snprintf (sql, sizeof(sql),
"UPDATE SharedRepo SET permission='%s' WHERE "
"repo_id='%s' AND from_email='%s' AND to_email='%s'",
permission, repo_id, from_email, to_email);
return seaf_db_query (mgr->seaf->db, sql);
}
static int
set_repo_size (SeafDB *db, const char *repo_id, const char *head_id, guint64 size)
{
char sql[256];
snprintf (sql, sizeof(sql),
"REPLACE INTO RepoSize (repo_id, size, head_id) "
"VALUES ('%s', %"G_GUINT64_FORMAT", '%s')",
repo_id, size, head_id);
if (seaf_db_query (db, sql) < 0)
return -1;
return 0;
}
int
seaf_share_manager_remove_repo (SeafShareManager *mgr, const char *repo_id)
{
char sql[512];
snprintf (sql, sizeof(sql),
"DELETE FROM SharedRepo WHERE repo_id = '%s'",
repo_id);
if (seaf_db_query (mgr->seaf->db, sql) < 0)
return -1;
return 0;
}
static int
create_repo_stat_tables (SeafileSession *session)
{
SeafDB *db = session->db;
char *sql = "CREATE TABLE IF NOT EXISTS RepoSize ("
"repo_id CHAR(37) PRIMARY KEY,"
"size BIGINT UNSIGNED,"
"head_id CHAR(41))";
if (seaf_db_query (db, sql) < 0)
return -1;
return 0;
}
int
seaf_share_manager_remove_share (SeafShareManager *mgr, const char *repo_id,
const char *from_email, const char *to_email)
{
char sql[512];
snprintf (sql, sizeof(sql),
"DELETE FROM SharedRepo WHERE repo_id = '%s' AND from_email ="
" '%s' AND to_email = '%s'", repo_id, from_email, to_email);
if (seaf_db_query (mgr->seaf->db, sql) < 0)
return -1;
return 0;
}
int
seaf_share_manager_add_share (SeafShareManager *mgr, const char *repo_id,
const char *from_email, const char *to_email,
const char *permission)
{
char sql[512];
snprintf (sql, sizeof(sql),
"SELECT repo_id from SharedRepo WHERE repo_id='%s' AND "
"from_email='%s' AND to_email='%s'", repo_id, from_email,
to_email);
if (seaf_db_check_for_existence (mgr->seaf->db, sql))
return 0;
snprintf (sql, sizeof(sql),
"INSERT INTO SharedRepo VALUES ('%s', '%s', '%s', '%s')", repo_id,
from_email, to_email, permission);
if (seaf_db_query (mgr->seaf->db, sql) < 0)
return -1;
return 0;
}
int
seaf_quota_manager_init (SeafQuotaManager *mgr)
{
SeafDB *db = mgr->session->db;
const char *sql;
switch (seaf_db_type(db)) {
case SEAF_DB_TYPE_SQLITE:
sql = "CREATE TABLE IF NOT EXISTS UserQuota (user VARCHAR(255) PRIMARY KEY,"
"quota BIGINT)";
if (seaf_db_query (db, sql) < 0)
return -1;
sql = "CREATE TABLE IF NOT EXISTS OrgQuota (org_id INTEGER PRIMARY KEY,"
"quota BIGINT)";
if (seaf_db_query (db, sql) < 0)
return -1;
sql = "CREATE TABLE IF NOT EXISTS OrgUserQuota (org_id INTEGER,"
"user VARCHAR(255), quota BIGINT, PRIMARY KEY (org_id, user))";
if (seaf_db_query (db, sql) < 0)
return -1;
break;
case SEAF_DB_TYPE_MYSQL:
sql = "CREATE TABLE IF NOT EXISTS UserQuota (user VARCHAR(255) PRIMARY KEY,"
"quota BIGINT) ENGINE=INNODB";
if (seaf_db_query (db, sql) < 0)
return -1;
sql = "CREATE TABLE IF NOT EXISTS OrgQuota (org_id INTEGER PRIMARY KEY,"
"quota BIGINT) ENGINE=INNODB";
if (seaf_db_query (db, sql) < 0)
return -1;
sql = "CREATE TABLE IF NOT EXISTS OrgUserQuota (org_id INTEGER,"
"user VARCHAR(255), quota BIGINT, PRIMARY KEY (org_id, user))"
"ENGINE=INNODB";
if (seaf_db_query (db, sql) < 0)
return -1;
break;
}
return 0;
}
static int
del_system_default_repo_id (SeafileSession *session)
{
const char *sql = "DELETE FROM SystemInfo WHERE info_key='default_repo_id'";
return seaf_db_query (session->db, sql);
}
int main (int argc, char **argv)
{
char sql[256];
gboolean verbose = FALSE;
gboolean use_mysql = FALSE;
int ret;
if (argc == 1)
usage(1);
int c;
while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) != EOF) {
switch (c) {
case 'h':
usage(0);
break;
case 'v':
verbose = TRUE;
break;
case 'm':
use_mysql = TRUE;
break;
case 's':
config.mysql_host = strdup(optarg);
break;
case 't':
config.mysql_socket = strdup(optarg);
break;
case 'r':
config.mysql_root_passwd = strdup(optarg);
break;
case 'd':
config.seafile_dir = strdup(optarg);
break;
case 'p':
config.port = strdup(optarg);
break;
case 'P':
config.httpserver_port = strdup(optarg);
break;
default:
usage(1);
}
}
if (use_mysql && !config.mysql_root_passwd) {
fprintf (stderr, "You choose to use mysql database. "
"Mysql Root Password must be specified.\n");
exit(1);
}
if (!config.seafile_dir) {
fprintf (stderr, "You must specify seafile data dir\n");
usage(1);
}
/* Create database for mysql */
if (use_mysql) {
SeafDB *db_root = seaf_db_new_mysql (config.mysql_host, "root",
config.mysql_root_passwd,
NULL, config.mysql_socket);
if (!db_root) {
fprintf (stderr, "Out of memory!\n");
return 1;
}
/* Create database for Seafile server. */
snprintf (sql, sizeof(sql), "CREATE DATABASE IF NOT EXISTS `%s`",
config.mysql_db_name);
ret = seaf_db_query (db_root, sql);
if (ret < 0) {
fprintf (stderr, "Failed to create database %s.\n", config.mysql_db_name);
return 1;
}
if (verbose)
printf ("Successfully created database: %s\n",
config.mysql_db_name);
/* Create database for Seahub. */
snprintf (sql, sizeof(sql), "CREATE DATABASE IF NOT EXISTS `%s` character set utf8",
config.mysql_seahub_db_name);
ret = seaf_db_query (db_root, sql);
if (ret < 0) {
fprintf (stderr, "Failed to create database %s.\n",
config.mysql_seahub_db_name);
return 1;
}
if (verbose)
printf ("Successfully created database: %s\n",
config.mysql_seahub_db_name);
}
/* Generate config file. */
GKeyFile *key_file = g_key_file_new ();
g_key_file_set_string (key_file, "database", "type",
use_mysql ? "mysql" : "sqlite");
if (use_mysql) {
g_key_file_set_string (key_file, "database", "host", config.mysql_host);
g_key_file_set_string (key_file, "database", "user", "root");
g_key_file_set_string (key_file, "database", "password", config.mysql_root_passwd);
g_key_file_set_string (key_file, "database", "db_name", config.mysql_db_name);
if (config.mysql_socket)
g_key_file_set_string (key_file, "database", "unix_socket", config.mysql_socket);
}
g_key_file_set_string (key_file, "network", "port", config.port);
if (config.httpserver_port) {
g_key_file_set_string (key_file, "httpserver", "port", config.httpserver_port);
} else {
/* httpserver port defaults to 8082 */
g_key_file_set_string (key_file, "httpserver", "port", "8082");
}
struct stat st;
if (lstat (config.seafile_dir, &st) < 0) {
if (mkdir (config.seafile_dir, 0777) < 0) {
fprintf (stderr, "Directory %s cannot be created.\n", config.seafile_dir);
return 1;
}
}
char *seafile_conf = g_build_filename (config.seafile_dir, "seafile.conf", NULL);
if (verbose)
printf ("Generating config files: %s\n", seafile_conf);
if (save_config_file (key_file, seafile_conf) < 0)
return 1;
printf ("Done.\n");
return 0;
}
