rugged-mysql 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce274abfec7be172fce34784845f6965c7d24abb
+  data.tar.gz: 0d23e7f09c4c85d512e1431273b2215fa517e5e0
+SHA512:
+  metadata.gz: d6acfd623e6b3dfcee07240a44d9baeb8e4bd08a121e3d5803510c66559fe87ff4d4c7da0d402a46b710334b88b1e89283717314c48f790a1b35bbfdf29defe9
+  data.tar.gz: 65fb60e0dbfc890f0c9dbe4aa04582452e200b47d993963cda2c6b4555d5f81235b90b93a8a0d30ee8cfa03355917994b10e82331769ccea0e816b50cde93b93

data/.gitignore

@@ -0,0 +1,5 @@
+.idea
+pkg
+tmp
+*.so
+*~

data/.ruby-version

@@ -0,0 +1 @@
+2.1.4

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rugged-mysql.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    rugged-mysql (0.0.1)
+      rugged (~> 0.21.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.3.2)
+    rake-compiler (0.9.3)
+      rake
+    rugged (0.21.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.7)
+  rake (~> 10.0)
+  rake-compiler
+  rugged-mysql!

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 重楼
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,40 @@
+rugged-mysql
+============
+
+Enables rugged to store git objects and references into MySQL.
+
+
+
+## Installation
+
+Add this line to you application's Gemfile:
+
+    gem 'rugged-mysql'
+Or:
+
+    gem 'rugged-mysql', chonglou/rugged-mysql
+
+And then execute:
+
+    bundle install
+
+
+## Usage
+
+Create the backend:
+
+    require 'rugged-mysql'
+    mysql_backend = Rugged::MySql::Backend.new(host:'localhost', port:3306, username:'git', password:'tig', database:'git')
+
+And pass it to rugged:
+    
+    repo = Rugged::Repository.bare('repo-name', backend:mysql_backend)
+
+Or
+
+    repo = Rugged::Repository.init_at('repo-name', :bare, backend:mysql_backend)
+
+
+Each instance of the backend consumes a single MySql connection.
+
+Enjoy it!

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new 'rugged-mysql' do |ext|
+  ext.lib_dir = 'lib/rugged/mysql'
+  ext.ext_dir = 'ext/rugged/mysql'
+end
+

data/ext/rugged/mysql/extconf.rb

@@ -0,0 +1,24 @@
+require 'mkmf'
+
+
+$CFLAGS << " #{ENV['CFLAGS']}"
+$CFLAGS << ' -I/usr/include/mysql'
+
+RUGGED_EXT_DIR = Gem::Specification.find_by_name('rugged').gem_dir
+puts "Using rugged headers from #{RUGGED_EXT_DIR}\n"
+$CFLAGS << " -I#{RUGGED_EXT_DIR}/ext/rugged"
+$CFLAGS << " -I#{RUGGED_EXT_DIR}/vendor/libgit2/include"
+$CFLAGS << " -I#{RUGGED_EXT_DIR}/vendor/libgit2/src"
+
+$CFLAGS << ' -g'
+$CFLAGS << ' -O3' unless $CFLAGS[/-O\d/]
+$CFLAGS << ' -Wall -Wno-comment -Wno-sizeof-pointer-memaccess'
+
+
+MAKE = find_executable('gmake') || find_executable('make')
+unless MAKE
+  abort 'ERROR: GNU make is required to build Rugged.'
+end
+
+create_makefile('rugged/mysql/rugged-mysql')
+

data/ext/rugged/mysql/mysql_odb_backend.c

@@ -0,0 +1,478 @@
+/*
+* source: https://github.com/libgit2/libgit2-backends/blob/master/mysql/mysql.c
+*/
+
+#include <assert.h>
+#include <string.h>
+#include <git2.h>
+#include <git2/sys/odb_backend.h>
+#include <mysql.h>
+
+#define GIT2_ODB_TABLE_NAME "git2_odb"
+#define GIT2_STORAGE_ENGINE "InnoDB"
+
+typedef struct {
+	git_odb_backend parent;
+	MYSQL *db;
+	MYSQL_STMT *st_read;
+	MYSQL_STMT *st_write;
+	MYSQL_STMT *st_read_header;
+} mysql_odb_backend;
+
+int
+mysql_odb_backend__read_header(size_t * len_p, git_otype * type_p,
+			       git_odb_backend * _backend, const git_oid * oid)
+{
+	mysql_odb_backend *backend;
+	int error;
+	MYSQL_BIND bind_buffers[1];
+	MYSQL_BIND result_buffers[2];
+
+	assert(len_p && type_p && _backend && oid);
+
+	backend = (mysql_odb_backend *) _backend;
+	error = GIT_ERROR;
+
+	memset(bind_buffers, 0, sizeof(bind_buffers));
+	memset(result_buffers, 0, sizeof(result_buffers));
+
+	// bind the oid passed to the statement
+	bind_buffers[0].buffer = (void *)oid->id;
+	bind_buffers[0].buffer_length = 20;
+	bind_buffers[0].length = &bind_buffers[0].buffer_length;
+	bind_buffers[0].buffer_type = MYSQL_TYPE_BLOB;
+	if (mysql_stmt_bind_param(backend->st_read_header, bind_buffers) != 0) {
+		return 0;
+	}
+	// execute the statement
+	if (mysql_stmt_execute(backend->st_read_header) != 0) {
+		return 0;
+	}
+	if (mysql_stmt_store_result(backend->st_read_header) != 0) {
+		return 0;
+	}
+	// this should either be 0 or 1
+	// if it's > 1 MySQL's unique index failed and we should all fear for our lives
+	if (mysql_stmt_num_rows(backend->st_read_header) == 1) {
+		result_buffers[0].buffer_type = MYSQL_TYPE_TINY;
+		result_buffers[0].buffer = type_p;
+		result_buffers[0].buffer_length = sizeof(type_p);
+		memset(type_p, 0, sizeof(type_p));
+
+		result_buffers[1].buffer_type = MYSQL_TYPE_LONGLONG;
+		result_buffers[1].buffer = len_p;
+		result_buffers[1].buffer_length = sizeof(len_p);
+		memset(len_p, 0, sizeof(len_p));
+
+		if (mysql_stmt_bind_result
+		    (backend->st_read_header, result_buffers) != 0) {
+			return GIT_ERROR;
+		}
+		// this should populate the buffers at *type_p and *len_p
+		if (mysql_stmt_fetch(backend->st_read_header) != 0) {
+			return GIT_ERROR;
+		}
+
+		error = GIT_OK;
+	} else {
+		error = GIT_ENOTFOUND;
+	}
+
+	// reset the statement for further use
+	if (mysql_stmt_reset(backend->st_read_header) != 0) {
+		return 0;
+	}
+
+	return error;
+}
+
+int
+mysql_odb_backend__read(void **data_p, size_t * len_p, git_otype * type_p,
+			git_odb_backend * _backend, const git_oid * oid)
+{
+	mysql_odb_backend *backend;
+	int error;
+	MYSQL_BIND bind_buffers[1];
+	MYSQL_BIND result_buffers[3];
+	unsigned long data_len;
+
+	assert(len_p && type_p && _backend && oid);
+
+	backend = (mysql_odb_backend *) _backend;
+	error = GIT_ERROR;
+
+	memset(bind_buffers, 0, sizeof(bind_buffers));
+	memset(result_buffers, 0, sizeof(result_buffers));
+
+	// bind the oid passed to the statement
+	bind_buffers[0].buffer = (void *)oid->id;
+	bind_buffers[0].buffer_length = 20;
+	bind_buffers[0].length = &bind_buffers[0].buffer_length;
+	bind_buffers[0].buffer_type = MYSQL_TYPE_BLOB;
+	if (mysql_stmt_bind_param(backend->st_read, bind_buffers) != 0) {
+		return 0;
+	}
+	// execute the statement
+	if (mysql_stmt_execute(backend->st_read) != 0) {
+		return 0;
+	}
+
+	if (mysql_stmt_store_result(backend->st_read) != 0) {
+		return 0;
+	}
+	// this should either be 0 or 1
+	// if it's > 1 MySQL's unique index failed and we should all fear for our lives
+	if (mysql_stmt_num_rows(backend->st_read) == 1) {
+		result_buffers[0].buffer_type = MYSQL_TYPE_TINY;
+		result_buffers[0].buffer = type_p;
+		result_buffers[0].buffer_length = sizeof(type_p);
+		memset(type_p, 0, sizeof(type_p));
+
+		result_buffers[1].buffer_type = MYSQL_TYPE_LONGLONG;
+		result_buffers[1].buffer = len_p;
+		result_buffers[1].buffer_length = sizeof(len_p);
+		memset(len_p, 0, sizeof(len_p));
+
+		// by setting buffer and buffer_length to 0, this tells libmysql
+		// we want it to set data_len to the *actual* length of that field
+		// this way we can malloc exactly as much memory as we need for the buffer
+		//
+		// come to think of it, we can probably just use the length set in *len_p
+		// once we fetch the result?
+		result_buffers[2].buffer_type = MYSQL_TYPE_LONG_BLOB;
+		result_buffers[2].buffer = 0;
+		result_buffers[2].buffer_length = 0;
+		result_buffers[2].length = &data_len;
+
+		if (mysql_stmt_bind_result(backend->st_read, result_buffers) !=
+		    0) {
+			return GIT_ERROR;
+		}
+		// this should populate the buffers at *type_p, *len_p and &data_len
+		error = mysql_stmt_fetch(backend->st_read);
+		// if(error != 0 || error != MYSQL_DATA_TRUNCATED)
+		//   return GIT_ERROR;
+
+		if (data_len > 0) {
+			*data_p = malloc(data_len);
+			result_buffers[2].buffer = *data_p;
+			result_buffers[2].buffer_length = data_len;
+
+			if (mysql_stmt_fetch_column
+			    (backend->st_read, &result_buffers[2], 2, 0) != 0) {
+				return GIT_ERROR;
+			}
+		}
+
+		error = GIT_OK;
+	} else {
+		error = GIT_ENOTFOUND;
+	}
+
+	// reset the statement for further use
+	if (mysql_stmt_reset(backend->st_read) != 0) {
+		return 0;
+	}
+
+	return error;
+}
+
+int mysql_odb_backend__exists(git_odb_backend * _backend, const git_oid * oid)
+{
+	mysql_odb_backend *backend;
+	int found;
+	MYSQL_BIND bind_buffers[1];
+
+	assert(_backend && oid);
+
+	backend = (mysql_odb_backend *) _backend;
+	found = 0;
+
+	memset(bind_buffers, 0, sizeof(bind_buffers));
+
+	// bind the oid passed to the statement
+	bind_buffers[0].buffer = (void *)oid->id;
+	bind_buffers[0].buffer_length = 20;
+	bind_buffers[0].length = &bind_buffers[0].buffer_length;
+	bind_buffers[0].buffer_type = MYSQL_TYPE_BLOB;
+	if (mysql_stmt_bind_param(backend->st_read_header, bind_buffers) != 0) {
+		return 0;
+	}
+	// execute the statement
+	if (mysql_stmt_execute(backend->st_read_header) != 0) {
+		return 0;
+	}
+
+	if (mysql_stmt_store_result(backend->st_read_header) != 0) {
+		return 0;
+	}
+	// now lets see if any rows matched our query
+	// this should either be 0 or 1
+	// if it's > 1 MySQL's unique index failed and we should all fear for our lives
+	if (mysql_stmt_num_rows(backend->st_read_header) == 1) {
+		found = 1;
+	}
+	// reset the statement for further use
+	if (mysql_stmt_reset(backend->st_read_header) != 0) {
+		return 0;
+	}
+
+	return found;
+}
+
+int
+mysql_odb_backend__write(git_odb_backend * _backend, const git_oid * oid,
+			 const void *data, size_t len, git_otype type)
+{
+	int error;
+	mysql_odb_backend *backend;
+	MYSQL_BIND bind_buffers[4];
+	my_ulonglong affected_rows;
+
+	assert(oid && _backend && data);
+
+	backend = (mysql_odb_backend *) _backend;
+
+	if ((error = git_odb_hash(oid, data, len, type)) < 0) {
+		return error;
+	}
+
+	memset(bind_buffers, 0, sizeof(bind_buffers));
+
+	// bind the oid
+	bind_buffers[0].buffer = (void *)oid->id;
+	bind_buffers[0].buffer_length = 20;
+	bind_buffers[0].length = &bind_buffers[0].buffer_length;
+	bind_buffers[0].buffer_type = MYSQL_TYPE_BLOB;
+
+	// bind the type
+	bind_buffers[1].buffer = &type;
+	bind_buffers[1].buffer_type = MYSQL_TYPE_TINY;
+
+	// bind the size of the data
+	bind_buffers[2].buffer = &len;
+	bind_buffers[2].buffer_type = MYSQL_TYPE_LONG;
+
+	// bind the data
+	bind_buffers[3].buffer = (void *)data;
+	bind_buffers[3].buffer_length = len;
+	bind_buffers[3].length = &bind_buffers[3].buffer_length;
+	bind_buffers[3].buffer_type = MYSQL_TYPE_BLOB;
+
+	if (mysql_stmt_bind_param(backend->st_write, bind_buffers) != 0) {
+		return GIT_ERROR;
+	}
+	// TODO: use the streaming backend API so this actually makes sense to use :P
+	// once we want to use this we should comment out
+	// if (mysql_stmt_send_long_data(backend->st_write, 2, data, len) != 0)
+	//   return GIT_ERROR;
+
+	// execute the statement
+	if (mysql_stmt_execute(backend->st_write) != 0) {
+		return GIT_ERROR;
+	}
+	// now lets see if the insert worked
+	affected_rows = mysql_stmt_affected_rows(backend->st_write);
+	if (affected_rows != 1) {
+		return GIT_ERROR;
+	}
+	// reset the statement for further use
+	if (mysql_stmt_reset(backend->st_read_header) != 0) {
+		return GIT_ERROR;
+	}
+
+	return GIT_OK;
+}
+
+void mysql_odb_backend__free(git_odb_backend * _backend)
+{
+	mysql_odb_backend *backend;
+	assert(_backend);
+	backend = (mysql_odb_backend *) _backend;
+
+	if (backend->st_read) {
+		mysql_stmt_close(backend->st_read);
+	}
+	if (backend->st_read_header) {
+		mysql_stmt_close(backend->st_read_header);
+	}
+	if (backend->st_write) {
+		mysql_stmt_close(backend->st_write);
+	}
+
+	mysql_close(backend->db);
+
+	free(backend);
+}
+
+static int create_table(MYSQL * db)
+{
+	static const char *sql_create =
+	    "CREATE TABLE `" GIT2_ODB_TABLE_NAME "` ("
+	    "  `oid` binary(20) NOT NULL DEFAULT '',"
+	    "  `type` tinyint(1) unsigned NOT NULL,"
+	    "  `size` bigint(20) unsigned NOT NULL,"
+	    "  `data` longblob NOT NULL,"
+	    "  PRIMARY KEY (`oid`),"
+	    "  KEY `type` (`type`),"
+	    "  KEY `size` (`size`)"
+	    ") ENGINE=" GIT2_STORAGE_ENGINE
+	    " DEFAULT CHARSET=utf8 COLLATE=utf8_bin;";
+
+	if (mysql_real_query(db, sql_create, strlen(sql_create)) != 0) {
+		return GIT_ERROR;
+	}
+
+	return GIT_OK;
+}
+
+static int init_db(MYSQL * db)
+{
+	static const char *sql_check =
+	    "SHOW TABLES LIKE '" GIT2_ODB_TABLE_NAME "';";
+
+	MYSQL_RES *res;
+	int error;
+	my_ulonglong num_rows;
+
+	if (mysql_real_query(db, sql_check, strlen(sql_check)) != 0)
+		return GIT_ERROR;
+
+	res = mysql_store_result(db);
+	if (res == NULL)
+		return GIT_ERROR;
+
+	num_rows = mysql_num_rows(res);
+	if (num_rows == 0) {
+		/* the table was not found */
+		error = create_table(db);
+	} else if (num_rows > 0) {
+		/* the table was found */
+		error = GIT_OK;
+	} else {
+		error = GIT_ERROR;
+	}
+
+	mysql_free_result(res);
+	return error;
+}
+
+static int init_statements(mysql_odb_backend * backend)
+{
+	my_bool truth = 1;
+
+	static const char *sql_read =
+	    "SELECT `type`, `size`, UNCOMPRESS(`data`) FROM `"
+	    GIT2_ODB_TABLE_NAME "` WHERE `oid` = ?;";
+
+	static const char *sql_read_header =
+	    "SELECT `type`, `size` FROM `" GIT2_ODB_TABLE_NAME
+	    "` WHERE `oid` = ?;";
+
+	static const char *sql_write =
+	    "INSERT IGNORE INTO `" GIT2_ODB_TABLE_NAME
+	    "` VALUES (?, ?, ?, COMPRESS(?));";
+
+	backend->st_read = mysql_stmt_init(backend->db);
+	if (backend->st_read == NULL) {
+		return GIT_ERROR;
+	}
+
+	if (mysql_stmt_attr_set
+	    (backend->st_read, STMT_ATTR_UPDATE_MAX_LENGTH, &truth) != 0) {
+		return GIT_ERROR;
+	}
+
+	if (mysql_stmt_prepare(backend->st_read, sql_read, strlen(sql_read)) !=
+	    0) {
+		return GIT_ERROR;
+	}
+
+	backend->st_read_header = mysql_stmt_init(backend->db);
+	if (backend->st_read_header == NULL) {
+		return GIT_ERROR;
+	}
+
+	if (mysql_stmt_attr_set
+	    (backend->st_read_header, STMT_ATTR_UPDATE_MAX_LENGTH, &truth) != 0)
+	{
+		return GIT_ERROR;
+	}
+
+	if (mysql_stmt_prepare
+	    (backend->st_read_header, sql_read_header, strlen(sql_read)) != 0) {
+		return GIT_ERROR;
+	}
+
+	backend->st_write = mysql_stmt_init(backend->db);
+	if (backend->st_write == NULL) {
+		return GIT_ERROR;
+	}
+
+	if (mysql_stmt_attr_set
+	    (backend->st_write, STMT_ATTR_UPDATE_MAX_LENGTH, &truth) != 0) {
+		return GIT_ERROR;
+	}
+
+	if (mysql_stmt_prepare(backend->st_write, sql_write, strlen(sql_read))
+	    != 0) {
+		return GIT_ERROR;
+	}
+
+	return GIT_OK;
+}
+
+int
+git_odb_backend_mysql(git_odb_backend ** backend_out, const char *mysql_host,
+		      unsigned int mysql_port,
+		      const char *mysql_unix_socket,
+		      const char *mysql_db,
+		      const char *mysql_user, const char *mysql_passwd,
+		      unsigned long mysql_client_flag)
+{
+	mysql_odb_backend *backend;
+	int error;
+	my_bool reconnect;
+
+	backend = calloc(1, sizeof(mysql_odb_backend));
+	if (backend == NULL) {
+		return GITERR_NOMEMORY;
+	}
+
+	backend->db = mysql_init(backend->db);
+
+	reconnect = 1;
+	// allow libmysql to reconnect gracefully
+	if (mysql_options(backend->db, MYSQL_OPT_RECONNECT, &reconnect) != 0) {
+		goto cleanup;
+	}
+	// make the connection
+	if (mysql_real_connect
+	    (backend->db, mysql_host, mysql_user, mysql_passwd, mysql_db,
+	     mysql_port, mysql_unix_socket, mysql_client_flag) != backend->db) {
+		goto cleanup;
+	}
+	// check for and possibly create the database
+	error = init_db(backend->db);
+	if (error < 0) {
+		goto cleanup;
+	}
+
+	error = init_statements(backend);
+	if (error < 0) {
+		goto cleanup;
+	}
+
+	backend->parent.read = &mysql_odb_backend__read;
+	backend->parent.read_header = &mysql_odb_backend__read_header;
+	backend->parent.write = &mysql_odb_backend__write;
+	backend->parent.exists = &mysql_odb_backend__exists;
+	backend->parent.free = &mysql_odb_backend__free;
+
+	*backend_out = (git_odb_backend *) backend;
+	return GIT_OK;
+
+ cleanup:
+	mysql_odb_backend__free((git_odb_backend *) backend);
+	return GIT_ERROR;
+}