diff --git a/ext/rugged/khash.h b/ext/rugged/khash.h new file mode 100644 index 000000000..e44f3288a --- /dev/null +++ b/ext/rugged/khash.h @@ -0,0 +1,627 @@ +/* The MIT License + + Copyright (c) 2008, 2009, 2011 by Attractive Chaos + + 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. +*/ + +/* + An example: + +#include "khash.h" +KHASH_MAP_INIT_INT(32, char) +int main() { + int ret, is_missing; + khiter_t k; + khash_t(32) *h = kh_init(32); + k = kh_put(32, h, 5, &ret); + kh_value(h, k) = 10; + k = kh_get(32, h, 10); + is_missing = (k == kh_end(h)); + k = kh_get(32, h, 5); + kh_del(32, h, k); + for (k = kh_begin(h); k != kh_end(h); ++k) + if (kh_exist(h, k)) kh_value(h, k) = 1; + kh_destroy(32, h); + return 0; +} +*/ + +/* + 2013-05-02 (0.2.8): + + * Use quadratic probing. When the capacity is power of 2, stepping function + i*(i+1)/2 guarantees to traverse each bucket. It is better than double + hashing on cache performance and is more robust than linear probing. + + In theory, double hashing should be more robust than quadratic probing. + However, my implementation is probably not for large hash tables, because + the second hash function is closely tied to the first hash function, + which reduce the effectiveness of double hashing. + + Reference: http://research.cs.vt.edu/AVresearch/hashing/quadratic.php + + 2011-12-29 (0.2.7): + + * Minor code clean up; no actual effect. + + 2011-09-16 (0.2.6): + + * The capacity is a power of 2. This seems to dramatically improve the + speed for simple keys. Thank Zilong Tan for the suggestion. Reference: + + - http://code.google.com/p/ulib/ + - http://nothings.org/computer/judy/ + + * Allow to optionally use linear probing which usually has better + performance for random input. Double hashing is still the default as it + is more robust to certain non-random input. + + * Added Wang's integer hash function (not used by default). This hash + function is more robust to certain non-random input. + + 2011-02-14 (0.2.5): + + * Allow to declare global functions. + + 2009-09-26 (0.2.4): + + * Improve portability + + 2008-09-19 (0.2.3): + + * Corrected the example + * Improved interfaces + + 2008-09-11 (0.2.2): + + * Improved speed a little in kh_put() + + 2008-09-10 (0.2.1): + + * Added kh_clear() + * Fixed a compiling error + + 2008-09-02 (0.2.0): + + * Changed to token concatenation which increases flexibility. + + 2008-08-31 (0.1.2): + + * Fixed a bug in kh_get(), which has not been tested previously. + + 2008-08-31 (0.1.1): + + * Added destructor +*/ + + +#ifndef __AC_KHASH_H +#define __AC_KHASH_H + +/*! + @header + + Generic hash table library. + */ + +#define AC_VERSION_KHASH_H "0.2.8" + +#include +#include +#include + +/* compiler specific configuration */ + +#if UINT_MAX == 0xffffffffu +typedef unsigned int khint32_t; +#elif ULONG_MAX == 0xffffffffu +typedef unsigned long khint32_t; +#endif + +#if ULONG_MAX == ULLONG_MAX +typedef unsigned long khint64_t; +#else +typedef unsigned long long khint64_t; +#endif + +#ifndef kh_inline +#ifdef _MSC_VER +#define kh_inline __inline +#else +#define kh_inline inline +#endif +#endif /* kh_inline */ + +#ifndef klib_unused +#if (defined __clang__ && __clang_major__ >= 3) || (defined __GNUC__ && __GNUC__ >= 3) +#define klib_unused __attribute__ ((__unused__)) +#else +#define klib_unused +#endif +#endif /* klib_unused */ + +typedef khint32_t khint_t; +typedef khint_t khiter_t; + +#define __ac_isempty(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&2) +#define __ac_isdel(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&1) +#define __ac_iseither(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&3) +#define __ac_set_isdel_false(flag, i) (flag[i>>4]&=~(1ul<<((i&0xfU)<<1))) +#define __ac_set_isempty_false(flag, i) (flag[i>>4]&=~(2ul<<((i&0xfU)<<1))) +#define __ac_set_isboth_false(flag, i) (flag[i>>4]&=~(3ul<<((i&0xfU)<<1))) +#define __ac_set_isdel_true(flag, i) (flag[i>>4]|=1ul<<((i&0xfU)<<1)) + +#define __ac_fsize(m) ((m) < 16? 1 : (m)>>4) + +#ifndef kroundup32 +#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x)) +#endif + +#ifndef kcalloc +#define kcalloc(N,Z) calloc(N,Z) +#endif +#ifndef kmalloc +#define kmalloc(Z) malloc(Z) +#endif +#ifndef krealloc +#define krealloc(P,Z) realloc(P,Z) +#endif +#ifndef kfree +#define kfree(P) free(P) +#endif + +static const double __ac_HASH_UPPER = 0.77; + +#define __KHASH_TYPE(name, khkey_t, khval_t) \ + typedef struct kh_##name##_s { \ + khint_t n_buckets, size, n_occupied, upper_bound; \ + khint32_t *flags; \ + khkey_t *keys; \ + khval_t *vals; \ + } kh_##name##_t; + +#define __KHASH_PROTOTYPES(name, khkey_t, khval_t) \ + extern kh_##name##_t *kh_init_##name(void); \ + extern void kh_destroy_##name(kh_##name##_t *h); \ + extern void kh_clear_##name(kh_##name##_t *h); \ + extern khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key); \ + extern int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets); \ + extern khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret); \ + extern void kh_del_##name(kh_##name##_t *h, khint_t x); + +#define __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ + SCOPE kh_##name##_t *kh_init_##name(void) { \ + return (kh_##name##_t*)kcalloc(1, sizeof(kh_##name##_t)); \ + } \ + SCOPE void kh_destroy_##name(kh_##name##_t *h) \ + { \ + if (h) { \ + kfree((void *)h->keys); kfree(h->flags); \ + kfree((void *)h->vals); \ + kfree(h); \ + } \ + } \ + SCOPE void kh_clear_##name(kh_##name##_t *h) \ + { \ + if (h && h->flags) { \ + memset(h->flags, 0xaa, __ac_fsize(h->n_buckets) * sizeof(khint32_t)); \ + h->size = h->n_occupied = 0; \ + } \ + } \ + SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) \ + { \ + if (h->n_buckets) { \ + khint_t k, i, last, mask, step = 0; \ + mask = h->n_buckets - 1; \ + k = __hash_func(key); i = k & mask; \ + last = i; \ + while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \ + i = (i + (++step)) & mask; \ + if (i == last) return h->n_buckets; \ + } \ + return __ac_iseither(h->flags, i)? h->n_buckets : i; \ + } else return 0; \ + } \ + SCOPE int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \ + { /* This function uses 0.25*n_buckets bytes of working space instead of [sizeof(key_t+val_t)+.25]*n_buckets. */ \ + khint32_t *new_flags = 0; \ + khint_t j = 1; \ + { \ + kroundup32(new_n_buckets); \ + if (new_n_buckets < 4) new_n_buckets = 4; \ + if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) j = 0; /* requested size is too small */ \ + else { /* hash table size to be changed (shrink or expand); rehash */ \ + new_flags = (khint32_t*)kmalloc(__ac_fsize(new_n_buckets) * sizeof(khint32_t)); \ + if (!new_flags) return -1; \ + memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \ + if (h->n_buckets < new_n_buckets) { /* expand */ \ + khkey_t *new_keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \ + if (!new_keys) { kfree(new_flags); return -1; } \ + h->keys = new_keys; \ + if (kh_is_map) { \ + khval_t *new_vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \ + if (!new_vals) { kfree(new_flags); return -1; } \ + h->vals = new_vals; \ + } \ + } /* otherwise shrink */ \ + } \ + } \ + if (j) { /* rehashing is needed */ \ + for (j = 0; j != h->n_buckets; ++j) { \ + if (__ac_iseither(h->flags, j) == 0) { \ + khkey_t key = h->keys[j]; \ + khval_t val; \ + khint_t new_mask; \ + new_mask = new_n_buckets - 1; \ + if (kh_is_map) val = h->vals[j]; \ + __ac_set_isdel_true(h->flags, j); \ + while (1) { /* kick-out process; sort of like in Cuckoo hashing */ \ + khint_t k, i, step = 0; \ + k = __hash_func(key); \ + i = k & new_mask; \ + while (!__ac_isempty(new_flags, i)) i = (i + (++step)) & new_mask; \ + __ac_set_isempty_false(new_flags, i); \ + if (i < h->n_buckets && __ac_iseither(h->flags, i) == 0) { /* kick out the existing element */ \ + { khkey_t tmp = h->keys[i]; h->keys[i] = key; key = tmp; } \ + if (kh_is_map) { khval_t tmp = h->vals[i]; h->vals[i] = val; val = tmp; } \ + __ac_set_isdel_true(h->flags, i); /* mark it as deleted in the old hash table */ \ + } else { /* write the element and jump out of the loop */ \ + h->keys[i] = key; \ + if (kh_is_map) h->vals[i] = val; \ + break; \ + } \ + } \ + } \ + } \ + if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \ + h->keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \ + if (kh_is_map) h->vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \ + } \ + kfree(h->flags); /* free the working space */ \ + h->flags = new_flags; \ + h->n_buckets = new_n_buckets; \ + h->n_occupied = h->size; \ + h->upper_bound = (khint_t)(h->n_buckets * __ac_HASH_UPPER + 0.5); \ + } \ + return 0; \ + } \ + SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret) \ + { \ + khint_t x; \ + if (h->n_occupied >= h->upper_bound) { /* update the hash table */ \ + if (h->n_buckets > (h->size<<1)) { \ + if (kh_resize_##name(h, h->n_buckets - 1) < 0) { /* clear "deleted" elements */ \ + *ret = -1; return h->n_buckets; \ + } \ + } else if (kh_resize_##name(h, h->n_buckets + 1) < 0) { /* expand the hash table */ \ + *ret = -1; return h->n_buckets; \ + } \ + } /* TODO: to implement automatically shrinking; resize() already support shrinking */ \ + { \ + khint_t k, i, site, last, mask = h->n_buckets - 1, step = 0; \ + x = site = h->n_buckets; k = __hash_func(key); i = k & mask; \ + if (__ac_isempty(h->flags, i)) x = i; /* for speed up */ \ + else { \ + last = i; \ + while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \ + if (__ac_isdel(h->flags, i)) site = i; \ + i = (i + (++step)) & mask; \ + if (i == last) { x = site; break; } \ + } \ + if (x == h->n_buckets) { \ + if (__ac_isempty(h->flags, i) && site != h->n_buckets) x = site; \ + else x = i; \ + } \ + } \ + } \ + if (__ac_isempty(h->flags, x)) { /* not present at all */ \ + h->keys[x] = key; \ + __ac_set_isboth_false(h->flags, x); \ + ++h->size; ++h->n_occupied; \ + *ret = 1; \ + } else if (__ac_isdel(h->flags, x)) { /* deleted */ \ + h->keys[x] = key; \ + __ac_set_isboth_false(h->flags, x); \ + ++h->size; \ + *ret = 2; \ + } else *ret = 0; /* Don't touch h->keys[x] if present and not deleted */ \ + return x; \ + } \ + SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x) \ + { \ + if (x != h->n_buckets && !__ac_iseither(h->flags, x)) { \ + __ac_set_isdel_true(h->flags, x); \ + --h->size; \ + } \ + } + +#define KHASH_DECLARE(name, khkey_t, khval_t) \ + __KHASH_TYPE(name, khkey_t, khval_t) \ + __KHASH_PROTOTYPES(name, khkey_t, khval_t) + +#define KHASH_INIT2(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ + __KHASH_TYPE(name, khkey_t, khval_t) \ + __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) + +#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ + KHASH_INIT2(name, static kh_inline klib_unused, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) + +/* --- BEGIN OF HASH FUNCTIONS --- */ + +/*! @function + @abstract Integer hash function + @param key The integer [khint32_t] + @return The hash value [khint_t] + */ +#define kh_int_hash_func(key) (khint32_t)(key) +/*! @function + @abstract Integer comparison function + */ +#define kh_int_hash_equal(a, b) ((a) == (b)) +/*! @function + @abstract 64-bit integer hash function + @param key The integer [khint64_t] + @return The hash value [khint_t] + */ +#define kh_int64_hash_func(key) (khint32_t)((key)>>33^(key)^(key)<<11) +/*! @function + @abstract 64-bit integer comparison function + */ +#define kh_int64_hash_equal(a, b) ((a) == (b)) +/*! @function + @abstract const char* hash function + @param s Pointer to a null terminated string + @return The hash value + */ +static kh_inline khint_t __ac_X31_hash_string(const char *s) +{ + khint_t h = (khint_t)*s; + if (h) for (++s ; *s; ++s) h = (h << 5) - h + (khint_t)*s; + return h; +} +/*! @function + @abstract Another interface to const char* hash function + @param key Pointer to a null terminated string [const char*] + @return The hash value [khint_t] + */ +#define kh_str_hash_func(key) __ac_X31_hash_string(key) +/*! @function + @abstract Const char* comparison function + */ +#define kh_str_hash_equal(a, b) (strcmp(a, b) == 0) + +static kh_inline khint_t __ac_Wang_hash(khint_t key) +{ + key += ~(key << 15); + key ^= (key >> 10); + key += (key << 3); + key ^= (key >> 6); + key += ~(key << 11); + key ^= (key >> 16); + return key; +} +#define kh_int_hash_func2(key) __ac_Wang_hash((khint_t)key) + +/* --- END OF HASH FUNCTIONS --- */ + +/* Other convenient macros... */ + +/*! + @abstract Type of the hash table. + @param name Name of the hash table [symbol] + */ +#define khash_t(name) kh_##name##_t + +/*! @function + @abstract Initiate a hash table. + @param name Name of the hash table [symbol] + @return Pointer to the hash table [khash_t(name)*] + */ +#define kh_init(name) kh_init_##name() + +/*! @function + @abstract Destroy a hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + */ +#define kh_destroy(name, h) kh_destroy_##name(h) + +/*! @function + @abstract Reset a hash table without deallocating memory. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + */ +#define kh_clear(name, h) kh_clear_##name(h) + +/*! @function + @abstract Resize a hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param s New size [khint_t] + */ +#define kh_resize(name, h, s) kh_resize_##name(h, s) + +/*! @function + @abstract Insert a key to the hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param k Key [type of keys] + @param r Extra return code: -1 if the operation failed; + 0 if the key is present in the hash table; + 1 if the bucket is empty (never used); 2 if the element in + the bucket has been deleted [int*] + @return Iterator to the inserted element [khint_t] + */ +#define kh_put(name, h, k, r) kh_put_##name(h, k, r) + +/*! @function + @abstract Retrieve a key from the hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param k Key [type of keys] + @return Iterator to the found element, or kh_end(h) if the element is absent [khint_t] + */ +#define kh_get(name, h, k) kh_get_##name(h, k) + +/*! @function + @abstract Remove a key from the hash table. + @param name Name of the hash table [symbol] + @param h Pointer to the hash table [khash_t(name)*] + @param k Iterator to the element to be deleted [khint_t] + */ +#define kh_del(name, h, k) kh_del_##name(h, k) + +/*! @function + @abstract Test whether a bucket contains data. + @param h Pointer to the hash table [khash_t(name)*] + @param x Iterator to the bucket [khint_t] + @return 1 if containing data; 0 otherwise [int] + */ +#define kh_exist(h, x) (!__ac_iseither((h)->flags, (x))) + +/*! @function + @abstract Get key given an iterator + @param h Pointer to the hash table [khash_t(name)*] + @param x Iterator to the bucket [khint_t] + @return Key [type of keys] + */ +#define kh_key(h, x) ((h)->keys[x]) + +/*! @function + @abstract Get value given an iterator + @param h Pointer to the hash table [khash_t(name)*] + @param x Iterator to the bucket [khint_t] + @return Value [type of values] + @discussion For hash sets, calling this results in segfault. + */ +#define kh_val(h, x) ((h)->vals[x]) + +/*! @function + @abstract Alias of kh_val() + */ +#define kh_value(h, x) ((h)->vals[x]) + +/*! @function + @abstract Get the start iterator + @param h Pointer to the hash table [khash_t(name)*] + @return The start iterator [khint_t] + */ +#define kh_begin(h) (khint_t)(0) + +/*! @function + @abstract Get the end iterator + @param h Pointer to the hash table [khash_t(name)*] + @return The end iterator [khint_t] + */ +#define kh_end(h) ((h)->n_buckets) + +/*! @function + @abstract Get the number of elements in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @return Number of elements in the hash table [khint_t] + */ +#define kh_size(h) ((h)->size) + +/*! @function + @abstract Get the number of buckets in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @return Number of buckets in the hash table [khint_t] + */ +#define kh_n_buckets(h) ((h)->n_buckets) + +/*! @function + @abstract Iterate over the entries in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @param kvar Variable to which key will be assigned + @param vvar Variable to which value will be assigned + @param code Block of code to execute + */ +#define kh_foreach(h, kvar, vvar, code) { khint_t __i; \ + for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \ + if (!kh_exist(h,__i)) continue; \ + (kvar) = kh_key(h,__i); \ + (vvar) = kh_val(h,__i); \ + code; \ + } } + +/*! @function + @abstract Iterate over the values in the hash table + @param h Pointer to the hash table [khash_t(name)*] + @param vvar Variable to which value will be assigned + @param code Block of code to execute + */ +#define kh_foreach_value(h, vvar, code) { khint_t __i; \ + for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \ + if (!kh_exist(h,__i)) continue; \ + (vvar) = kh_val(h,__i); \ + code; \ + } } + +/* More conenient interfaces */ + +/*! @function + @abstract Instantiate a hash set containing integer keys + @param name Name of the hash table [symbol] + */ +#define KHASH_SET_INIT_INT(name) \ + KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal) + +/*! @function + @abstract Instantiate a hash map containing integer keys + @param name Name of the hash table [symbol] + @param khval_t Type of values [type] + */ +#define KHASH_MAP_INIT_INT(name, khval_t) \ + KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal) + +/*! @function + @abstract Instantiate a hash map containing 64-bit integer keys + @param name Name of the hash table [symbol] + */ +#define KHASH_SET_INIT_INT64(name) \ + KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal) + +/*! @function + @abstract Instantiate a hash map containing 64-bit integer keys + @param name Name of the hash table [symbol] + @param khval_t Type of values [type] + */ +#define KHASH_MAP_INIT_INT64(name, khval_t) \ + KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal) + +typedef const char *kh_cstr_t; +/*! @function + @abstract Instantiate a hash map containing const char* keys + @param name Name of the hash table [symbol] + */ +#define KHASH_SET_INIT_STR(name) \ + KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal) + +/*! @function + @abstract Instantiate a hash map containing const char* keys + @param name Name of the hash table [symbol] + @param khval_t Type of values [type] + */ +#define KHASH_MAP_INIT_STR(name, khval_t) \ + KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal) + +#endif /* __AC_KHASH_H */ diff --git a/ext/rugged/rugged.c b/ext/rugged/rugged.c index b81bc4197..28294020a 100644 --- a/ext/rugged/rugged.c +++ b/ext/rugged/rugged.c @@ -5,6 +5,8 @@ * For full terms see the included LICENSE file. */ +#include +#include #include "rugged.h" const char *RUGGED_ERROR_NAMES[] = { @@ -515,8 +517,31 @@ VALUE rb_merge_file_result_fromC(const git_merge_file_result *result) return rb_result; } +#if GCRYPT_VERSION_NUMBER < 0x010600 +#include +#include + GCRY_THREAD_OPTION_PTHREAD_IMPL; +#endif + +void init_gcrypt(void) +{ + int rc; + +#if GCRYPT_VERSION_NUMBER >= 0x010600 + GCRY_THREAD_OPTION_PTHREAD_IMPL; +#endif + + if ((rc = gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread)) != GPG_ERR_NO_ERROR) { + rb_raise(rb_eRuntimeError, "gcry_control thread callbacks failed: %s\n", gpg_strerror(rc)); + } + if (!gcry_check_version(GCRYPT_VERSION)) { + rb_raise(rb_eRuntimeError, "gcry_check_version failed\n"); + } +} + void Init_rugged(void) { + init_gcrypt(); rb_mRugged = rb_define_module("Rugged"); /* Initialize the Error classes */ diff --git a/ext/rugged/rugged.h b/ext/rugged/rugged.h index 8a4585477..7300767cb 100644 --- a/ext/rugged/rugged.h +++ b/ext/rugged/rugged.h @@ -24,6 +24,10 @@ #include #include +#include "khash.h" + +KHASH_MAP_INIT_STR(map_charptr_to_charptr, char *) + #define rb_str_new_utf8(str) rb_enc_str_new(str, strlen(str), rb_utf8_encoding()) #define CSTR2SYM(s) (ID2SYM(rb_intern((s)))) @@ -137,6 +141,15 @@ struct rugged_cb_payload int exception; }; +struct rugged_remote_cb_payload_without_gvl +{ + int credentials_passthrough; + git_cred *credentials; + git_cred *credentials_username; + int certificate_check; + khash_t(map_charptr_to_charptr) *result; +}; + struct rugged_remote_cb_payload { VALUE progress; @@ -149,11 +162,32 @@ struct rugged_remote_cb_payload int exception; }; +struct rugged_git_clone_arg +{ + git_repository *repo; + char *url; + char *local_path; + git_clone_options *options; +}; + +struct rugged_git_remote_fetch_arg +{ + git_remote *remote; + git_strarray *refspecs; + git_fetch_options *opts; + char *log_message; +}; + void rugged_remote_init_callbacks_and_payload_from_options( VALUE rb_options, git_remote_callbacks *callbacks, struct rugged_remote_cb_payload *payload); +void rugged_remote_init_callbacks_and_payload_from_options_without_gvl( + VALUE rb_options, + git_remote_callbacks *callbacks, + struct rugged_remote_cb_payload_without_gvl *payload); + static inline void rugged_check_repo(VALUE rb_repo) { if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo)) diff --git a/ext/rugged/rugged_cred.c b/ext/rugged/rugged_cred.c index f8f7813e1..cf860f38d 100644 --- a/ext/rugged/rugged_cred.c +++ b/ext/rugged/rugged_cred.c @@ -90,18 +90,18 @@ void rugged_cred_extract(git_cred **cred, int allowed_types, VALUE rb_credential if (!(allowed_types & GIT_CREDTYPE_USERPASS_PLAINTEXT)) rb_raise(rb_eArgError, "Invalid credential type"); - rugged_cred_extract_userpass(cred, rb_credential); + rugged_cred_extract_userpass(cred, rb_credential); } else if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredSshKey)) { if (allowed_types & GIT_CREDTYPE_USERNAME) { rugged_cred_extract_username(cred, rb_credential); - return; + return; } if (!(allowed_types & GIT_CREDTYPE_SSH_KEY)) rb_raise(rb_eArgError, "Invalid credential type"); - rugged_cred_extract_ssh_key(cred, rb_credential); - } else if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredSshKeyFromAgent)) { + rugged_cred_extract_ssh_key(cred, rb_credential); + } else if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredSshKeyFromAgent)) { if (allowed_types & GIT_CREDTYPE_USERNAME) { rugged_cred_extract_username(cred, rb_credential); return; @@ -110,12 +110,13 @@ void rugged_cred_extract(git_cred **cred, int allowed_types, VALUE rb_credential if (!(allowed_types & GIT_CREDTYPE_SSH_KEY)) rb_raise(rb_eArgError, "Invalid credential type"); - rugged_credential_extract_ssh_key_from_agent(cred, rb_credential); - } else if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredDefault)) { + rugged_credential_extract_ssh_key_from_agent(cred, rb_credential); + + } else if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredDefault)) { if (!(allowed_types & GIT_CREDTYPE_DEFAULT)) rb_raise(rb_eArgError, "Invalid credential type"); - rugged_cred_extract_default(cred, rb_credential); + rugged_cred_extract_default(cred, rb_credential); } } diff --git a/ext/rugged/rugged_remote.c b/ext/rugged/rugged_remote.c index 6c19397e8..e748e93ae 100644 --- a/ext/rugged/rugged_remote.c +++ b/ext/rugged/rugged_remote.c @@ -6,11 +6,13 @@ */ #include "rugged.h" +#include extern VALUE rb_mRugged; extern VALUE rb_cRuggedRepo; extern VALUE rb_eRuggedError; VALUE rb_cRuggedRemote; +VALUE rb_cRuggedCredDefault; static int progress_cb(const char *str, int len, void *data) { @@ -50,6 +52,25 @@ static int transfer_progress_cb(const git_transfer_progress *stats, void *data) return payload->exception ? GIT_ERROR : GIT_OK; } +static int push_update_reference_without_gvl_cb(const char *refname, const char *status, void *data) +{ + struct rugged_remote_cb_payload_without_gvl *payload = data; + khiter_t key; + int rc; + + if (status != NULL) { + key = kh_put(map_charptr_to_charptr, payload->result, refname, &rc); + if (rc == -1 || rc == 0 || rc == 2) { + return GIT_ERROR; + } else if (rc == 1) { + kh_key(payload->result, key) = strdup(refname); + kh_val(payload->result, key) = strdup(status); + } + } + + return GIT_OK; +} + static int push_update_reference_cb(const char *refname, const char *status, void *data) { struct rugged_remote_cb_payload *payload = data; @@ -77,6 +98,13 @@ static int update_tips_cb(const char *refname, const git_oid *src, const git_oid return payload->exception ? GIT_ERROR : GIT_OK; } +static int certificate_check_without_gvl_cb(git_cert *cert, int valid, const char *host, void *data) +{ + struct rugged_remote_cb_payload_without_gvl *payload = data; + + return payload->certificate_check ? GIT_OK : GIT_ECERTIFICATE; +} + static int certificate_check_cb(git_cert *cert, int valid, const char *host, void *data) { struct rugged_remote_cb_payload *payload = data; @@ -137,6 +165,32 @@ static VALUE extract_cred(VALUE data) { return Qnil; } +static int credentials_without_gvl_cb( + git_cred **cred, + const char *url, + const char *username_from_url, + unsigned int allowed_types, + void *data) +{ + struct rugged_remote_cb_payload_without_gvl *payload = data; + + if (payload->credentials_passthrough) { + return GIT_PASSTHROUGH; + } + + if (payload->credentials_username && (allowed_types & GIT_CREDTYPE_USERNAME)) { + *cred = payload->credentials_username; + payload->credentials_username = NULL; + } else if (payload->credentials && (payload->credentials->credtype & allowed_types)) { + *cred = payload->credentials; + payload->credentials = NULL; + } else { + return GIT_ERROR; + } + + return GIT_OK; +} + static int credentials_cb( git_cred **cred, const char *url, @@ -157,6 +211,40 @@ static int credentials_cb( return payload->exception ? GIT_ERROR : GIT_OK; } +void rugged_remote_init_callbacks_and_payload_from_options_without_gvl( + VALUE rb_options, + git_remote_callbacks *callbacks, + struct rugged_remote_cb_payload_without_gvl *payload) +{ + VALUE credentials; + VALUE certificate_check; + + callbacks->payload = payload; + callbacks->push_update_reference = push_update_reference_without_gvl_cb; + + if (!NIL_P(rb_options)) { + credentials = rb_hash_aref(rb_options, CSTR2SYM("credentials")); + if (!NIL_P(credentials)) { + if (!rb_obj_is_kind_of(credentials, rb_cRuggedCredDefault)) { + rugged_cred_extract(&payload->credentials_username, GIT_CREDTYPE_USERNAME, credentials); + } + rugged_cred_extract( + &payload->credentials, + GIT_CREDTYPE_USERPASS_PLAINTEXT | GIT_CREDTYPE_SSH_KEY | GIT_CREDTYPE_DEFAULT, + credentials); + callbacks->credentials = credentials_without_gvl_cb; + } else { + payload->credentials_passthrough = 1; + } + + certificate_check = rb_hash_aref(rb_options, CSTR2SYM("certificate_check")); + if (!NIL_P(certificate_check)) { + payload->certificate_check = INT2FIX(certificate_check); + callbacks->certificate_check = certificate_check_without_gvl_cb; + } + } +} + #define CALLABLE_OR_RAISE(ret, name) \ do { \ if (!rb_respond_to(ret, rb_intern("call"))) \ @@ -638,6 +726,108 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self) return rb_result; } +/* + * call-seq: + * remote.fetch2(refspecs = nil, options = {}) -> hash + * + * Downloads new data from the remote for the given +refspecs+. + * + * You can optionally pass in a single or multiple alternative +refspecs+ to use instead of the fetch + * refspecs already configured for +remote+. + * + * Returns a hash containing statistics for the fetch operation. + * + * The following options can be passed in the +options+ Hash: + * + * :credentials :: + * The credentials to use for the fetch operation. Can be either an instance of one + * of the Rugged::Credentials types. + * + * :headers :: + * Extra HTTP headers to include with the request (only applies to http:// or https:// remotes) + * + * :certificate_check :: + * If cert verification fails, this will let the user make the final decision of whether + * to allow the connection to procesd. 1 to allow the connection, 0 to disallow it. + * + * :message :: + * The message to insert into the reflogs. Defaults to "fetch". + * + * :prune :: + * Specifies the prune mode for the fetch. +true+ remove any remote-tracking references that + * no longer exist, +false+ do not prune, +nil+ use configured settings Defaults to "nil". + */ +static void *git_remote_fetch_wrapper(void *data) +{ + int error; + + struct rugged_git_remote_fetch_arg *arg = data; + error = git_remote_fetch(arg->remote, arg->refspecs, arg->opts, arg->log_message); + + return (void *)(intptr_t) error; +} + +static VALUE rb_git_remote_fetch_without_gvl(int argc, VALUE *argv, VALUE self) +{ + struct rugged_git_remote_fetch_arg arg; + git_remote *remote; + git_strarray refspecs; + git_fetch_options opts = GIT_FETCH_OPTIONS_INIT; + const git_transfer_progress *stats; + struct rugged_remote_cb_payload_without_gvl payload = { 0, NULL, NULL, 0, NULL }; + + char *log_message = NULL; + int error; + + VALUE rb_options, rb_refspecs, rb_result = Qnil; + + rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options); + + rugged_rb_ary_to_strarray(rb_refspecs, &refspecs); + + Data_Get_Struct(self, git_remote, remote); + + rugged_remote_init_callbacks_and_payload_from_options_without_gvl(rb_options, &opts.callbacks, &payload); + init_custom_headers(rb_options, &opts.custom_headers); + + if (!NIL_P(rb_options)) { + VALUE rb_prune_type; + VALUE rb_val = rb_hash_aref(rb_options, CSTR2SYM("message")); + + if (!NIL_P(rb_val)) + log_message = StringValueCStr(rb_val); + + rb_prune_type = rb_hash_aref(rb_options, CSTR2SYM("prune")); + opts.prune = parse_prune_type(rb_prune_type); + } + + arg.remote = remote; + arg.refspecs = &refspecs; + arg.opts = &opts; + arg.log_message = log_message; + error = (intptr_t) rb_thread_call_without_gvl2(git_remote_fetch_wrapper, &arg, + RUBY_UBF_PROCESS, NULL); + rb_thread_check_ints(); + + xfree(refspecs.strings); + git_strarray_free(&opts.custom_headers); + + rugged_exception_check(error); + + stats = git_remote_stats(remote); + + rb_result = rb_hash_new(); + rb_hash_aset(rb_result, CSTR2SYM("total_objects"), UINT2NUM(stats->total_objects)); + rb_hash_aset(rb_result, CSTR2SYM("indexed_objects"), UINT2NUM(stats->indexed_objects)); + rb_hash_aset(rb_result, CSTR2SYM("received_objects"), UINT2NUM(stats->received_objects)); + rb_hash_aset(rb_result, CSTR2SYM("local_objects"), UINT2NUM(stats->local_objects)); + rb_hash_aset(rb_result, CSTR2SYM("total_deltas"), UINT2NUM(stats->total_deltas)); + rb_hash_aset(rb_result, CSTR2SYM("indexed_deltas"), UINT2NUM(stats->indexed_deltas)); + rb_hash_aset(rb_result, CSTR2SYM("received_bytes"), INT2FIX(stats->received_bytes)); + + return rb_result; +} + /* * call-seq: * remote.push(refspecs = nil, options = {}) -> hash @@ -715,5 +905,6 @@ void Init_rugged_remote(void) rb_define_method(rb_cRuggedRemote, "ls", rb_git_remote_ls, -1); rb_define_method(rb_cRuggedRemote, "check_connection", rb_git_remote_check_connection, -1); rb_define_method(rb_cRuggedRemote, "fetch", rb_git_remote_fetch, -1); + rb_define_method(rb_cRuggedRemote, "fetch2", rb_git_remote_fetch_without_gvl, -1); rb_define_method(rb_cRuggedRemote, "push", rb_git_remote_push, -1); } diff --git a/ext/rugged/rugged_repo.c b/ext/rugged/rugged_repo.c index 1ac827a23..a4ab23246 100644 --- a/ext/rugged/rugged_repo.c +++ b/ext/rugged/rugged_repo.c @@ -10,6 +10,7 @@ #include #include #include +#include extern VALUE rb_mRugged; extern VALUE rb_eRuggedError; @@ -416,6 +417,28 @@ static void parse_clone_options(git_clone_options *ret, VALUE rb_options, struct rugged_remote_init_callbacks_and_payload_from_options(rb_options, &ret->fetch_opts.callbacks, remote_payload); } +static void parse_clone_options_without_gvl(git_clone_options *ret, VALUE rb_options, + struct rugged_remote_cb_payload_without_gvl *remote_payload) +{ + VALUE val; + + if (NIL_P(rb_options)) + return; + + val = rb_hash_aref(rb_options, CSTR2SYM("bare")); + if (RTEST(val)) + ret->bare = 1; + + val = rb_hash_aref(rb_options, CSTR2SYM("checkout_branch")); + if (!NIL_P(val)) { + Check_Type(val, T_STRING); + ret->checkout_branch = StringValueCStr(val); + } + + rugged_remote_init_callbacks_and_payload_from_options_without_gvl(rb_options, + &ret->fetch_opts.callbacks, remote_payload); +} + /* * call-seq: * Repository.clone_at(url, local_path[, options]) -> repository @@ -487,6 +510,70 @@ static VALUE rb_git_repo_clone_at(int argc, VALUE *argv, VALUE klass) return rugged_repo_new(klass, repo); } +/* + * call-seq: + * Repository.clone_at2(url, local_path[, options]) -> repository + * + * Clone a repository from +url+ to +local_path+. + * + * The following options can be passed in the +options+ Hash: + * + * :bare :: + * If +true+, the clone will be created as a bare repository. + * Defaults to +false+. + * + * :checkout_branch :: + * The name of a branch to checkout. Defaults to the remote's +HEAD+. + * + * :remote :: + * The name to give to the "origin" remote. Defaults to "origin". + * + * :ignore_cert_errors :: + * If set to +true+, errors while validating the remote's host certificate will be ignored. + * + * :credentials :: + * The credentials to use for the fetch operation. Can be either an instance of one + * of the Rugged::Credentials types. + */ +static void *git_clone_wrapper(void *data) +{ + struct rugged_git_clone_arg *arg = data; + int error; + + error = git_clone(&arg->repo, arg->url, arg->local_path, arg->options); + + return (void *)(intptr_t) error; +} + +static VALUE rb_git_repo_clone_at_without_gvl(int argc, VALUE *argv, VALUE klass) +{ + struct rugged_git_clone_arg arg; + VALUE url, local_path, rb_options_hash; + git_clone_options options = GIT_CLONE_OPTIONS_INIT; + struct rugged_remote_cb_payload_without_gvl remote_payload = {0, NULL, NULL, 0, NULL}; + git_repository *repo; + int error; + + rb_scan_args(argc, argv, "21", &url, &local_path, &rb_options_hash); + Check_Type(url, T_STRING); + Check_Type(local_path, T_STRING); + + parse_clone_options_without_gvl(&options, rb_options_hash, &remote_payload); + + + arg.url = StringValueCStr(url); + arg.local_path = StringValueCStr(local_path); + arg.options = &options; + error = (intptr_t) rb_thread_call_without_gvl2(git_clone_wrapper, &arg, + RUBY_UBF_PROCESS, NULL); + rb_thread_check_ints(); + repo = arg.repo; + + rugged_exception_check(error); + + return rugged_repo_new(klass, repo); +} + #define RB_GIT_REPO_OWNED_GET(_klass, _object) \ VALUE rb_data = rb_iv_get(self, "@" #_object); \ if (NIL_P(rb_data)) { \ @@ -2557,6 +2644,7 @@ void Init_rugged_repo(void) rb_define_singleton_method(rb_cRuggedRepo, "init_at", rb_git_repo_init_at, -1); rb_define_singleton_method(rb_cRuggedRepo, "discover", rb_git_repo_discover, -1); rb_define_singleton_method(rb_cRuggedRepo, "clone_at", rb_git_repo_clone_at, -1); + rb_define_singleton_method(rb_cRuggedRepo, "clone_at2", rb_git_repo_clone_at_without_gvl, -1); rb_define_method(rb_cRuggedRepo, "close", rb_git_repo_close, 0); diff --git a/lib/rugged/version.rb b/lib/rugged/version.rb index 71f6d4c16..f0c968fd0 100644 --- a/lib/rugged/version.rb +++ b/lib/rugged/version.rb @@ -4,5 +4,5 @@ # For full terms see the included LICENSE file. module Rugged - Version = VERSION = '0.26.0' + Version = VERSION = '0.26.1' end