svn_error_t * svn_fs_create(svn_fs_t **fs_p, const char *path, apr_hash_t *fs_config, apr_pool_t *pool) { svn_error_t *err; svn_error_t *err2; fs_library_vtable_t *vtable; const char *fs_type = svn_hash__get_cstring(fs_config, SVN_FS_CONFIG_FS_TYPE, DEFAULT_FS_TYPE); SVN_ERR(get_library_vtable(&vtable, fs_type, pool)); /* Create the FS directory and write out the fsap-name file. */ SVN_ERR(svn_io_dir_make_sgid(path, APR_OS_DEFAULT, pool)); SVN_ERR(write_fs_type(path, fs_type, pool)); /* Perform the actual creation. */ *fs_p = fs_new(fs_config, pool); SVN_ERR(acquire_fs_mutex()); err = vtable->create(*fs_p, path, pool, common_pool); err2 = release_fs_mutex(); if (err) { svn_error_clear(err2); return svn_error_trace(err); } return svn_error_trace(err2); }
svn_boolean_t svn_hash__get_bool(apr_hash_t *hash, const char *key, svn_boolean_t default_value) { const char *tmp_value = svn_hash__get_cstring(hash, key, NULL); svn_tristate_t value = svn_tristate__from_word(tmp_value); if (value == svn_tristate_true) return TRUE; else if (value == svn_tristate_false) return FALSE; return default_value; }
svn_error_t * svn_fs_create(svn_fs_t **fs_p, const char *path, apr_hash_t *fs_config, apr_pool_t *pool) { fs_library_vtable_t *vtable; const char *fs_type = svn_hash__get_cstring(fs_config, SVN_FS_CONFIG_FS_TYPE, DEFAULT_FS_TYPE); SVN_ERR(get_library_vtable(&vtable, fs_type, pool)); /* Create the FS directory and write out the fsap-name file. */ SVN_ERR(svn_io_dir_make_sgid(path, APR_OS_DEFAULT, pool)); SVN_ERR(write_fs_type(path, fs_type, pool)); /* Perform the actual creation. */ *fs_p = fs_new(fs_config, pool); SVN_MUTEX__WITH_LOCK(common_pool_lock, vtable->create(*fs_p, path, pool, common_pool)); return SVN_NO_ERROR; }
static svn_error_t * multistatus_closed(svn_ra_serf__xml_estate_t *xes, void *baton, int leaving_state, const svn_string_t *cdata, apr_hash_t *attrs, apr_pool_t *scratch_pool) { struct svn_ra_serf__server_error_t *server_error = baton; const char *errcode; const char *status; switch (leaving_state) { case MS_RESPONSE_HREF: { apr_status_t result; apr_uri_t uri; result = apr_uri_parse(scratch_pool, cdata->data, &uri); if (result) return svn_ra_serf__wrap_err(result, NULL); svn_ra_serf__xml_note(xes, MS_RESPONSE, "path", svn_urlpath__canonicalize(uri.path, scratch_pool)); } break; case MS_RESPONSE_STATUS: svn_ra_serf__xml_note(xes, MS_RESPONSE, "status", cdata->data); break; case MS_RESPONSE_ERROR_HUMANREADABLE: svn_ra_serf__xml_note(xes, MS_RESPONSE, "human-readable", cdata->data); errcode = svn_hash_gets(attrs, "errcode"); if (errcode) svn_ra_serf__xml_note(xes, MS_RESPONSE, "errcode", errcode); break; case MS_RESPONSE: if ((status = svn_hash__get_cstring(attrs, "status", NULL)) != NULL) { error_item_t *item; item = apr_pcalloc(server_error->pool, sizeof(*item)); item->path = apr_pstrdup(server_error->pool, svn_hash_gets(attrs, "path")); SVN_ERR(parse_status_line(&item->http_status, &item->http_reason, status, server_error->pool, scratch_pool)); /* Do we have a mod_dav specific message? */ item->message = svn_hash_gets(attrs, "human-readable"); if (item->message) { if ((errcode = svn_hash_gets(attrs, "errcode")) != NULL) { apr_int64_t val; SVN_ERR(svn_cstring_atoi64(&val, errcode)); item->apr_err = (apr_status_t)val; } item->message = apr_pstrdup(server_error->pool, item->message); } else item->message = apr_pstrdup(server_error->pool, svn_hash_gets(attrs, "description")); APR_ARRAY_PUSH(server_error->items, error_item_t *) = item; } break; case MS_PROPSTAT_STATUS: svn_ra_serf__xml_note(xes, MS_PROPSTAT, "status", cdata->data); break; case MS_PROPSTAT_ERROR_HUMANREADABLE: svn_ra_serf__xml_note(xes, MS_PROPSTAT, "human-readable", cdata->data); errcode = svn_hash_gets(attrs, "errcode"); if (errcode) svn_ra_serf__xml_note(xes, MS_PROPSTAT, "errcode", errcode); break; case MS_PROPSTAT_RESPONSEDESCRIPTION: svn_ra_serf__xml_note(xes, MS_PROPSTAT, "description", cdata->data); break; case MS_PROPSTAT: if ((status = svn_hash__get_cstring(attrs, "status", NULL)) != NULL) { apr_hash_t *response_attrs; error_item_t *item; response_attrs = svn_ra_serf__xml_gather_since(xes, MS_RESPONSE); item = apr_pcalloc(server_error->pool, sizeof(*item)); item->path = apr_pstrdup(server_error->pool, svn_hash_gets(response_attrs, "path")); item->propname = apr_pstrdup(server_error->pool, svn_hash_gets(attrs, "propname")); SVN_ERR(parse_status_line(&item->http_status, &item->http_reason, status, server_error->pool, scratch_pool)); /* Do we have a mod_dav specific message? */ item->message = svn_hash_gets(attrs, "human-readable"); if (item->message) { if ((errcode = svn_hash_gets(attrs, "errcode")) != NULL) { apr_int64_t val; SVN_ERR(svn_cstring_atoi64(&val, errcode)); item->apr_err = (apr_status_t)val; } item->message = apr_pstrdup(server_error->pool, item->message); } else item->message = apr_pstrdup(server_error->pool, svn_hash_gets(attrs, "description")); APR_ARRAY_PUSH(server_error->items, error_item_t *) = item; }
/* Return a memcache in *MEMCACHE_P for FS if it's configured to use memcached, or NULL otherwise. Also, sets *FAIL_STOP to a boolean indicating whether cache errors should be returned to the caller or just passed to the FS warning handler. *CACHE_TXDELTAS, *CACHE_FULLTEXTS and *CACHE_REVPROPS flags will be set according to FS->CONFIG. *CACHE_NAMESPACE receives the cache prefix to use. Use FS->pool for allocating the memcache and CACHE_NAMESPACE, and POOL for temporary allocations. */ static svn_error_t * read_config(svn_memcache_t **memcache_p, svn_boolean_t *fail_stop, const char **cache_namespace, svn_boolean_t *cache_txdeltas, svn_boolean_t *cache_fulltexts, svn_boolean_t *cache_revprops, svn_fs_t *fs, apr_pool_t *pool) { fs_fs_data_t *ffd = fs->fsap_data; SVN_ERR(svn_cache__make_memcache_from_config(memcache_p, ffd->config, fs->pool)); /* No cache namespace by default. I.e. all FS instances share the * cached data. If you specify different namespaces, the data will * share / compete for the same cache memory but keys will not match * across namespaces and, thus, cached data will not be shared between * namespaces. * * Since the namespace will be concatenated with other elements to form * the complete key prefix, we must make sure that the resulting string * is unique and cannot be created by any other combination of elements. */ *cache_namespace = normalize_key_part(svn_hash__get_cstring(fs->config, SVN_FS_CONFIG_FSFS_CACHE_NS, ""), pool); /* don't cache text deltas by default. * Once we reconstructed the fulltexts from the deltas, * these deltas are rarely re-used. Therefore, only tools * like svnadmin will activate this to speed up operations * dump and verify. */ *cache_txdeltas = svn_hash__get_bool(fs->config, SVN_FS_CONFIG_FSFS_CACHE_DELTAS, FALSE); /* by default, cache fulltexts. * Most SVN tools care about reconstructed file content. * Thus, this is a reasonable default. * SVN admin tools may set that to FALSE because fulltexts * won't be re-used rendering the cache less effective * by squeezing wanted data out. */ *cache_fulltexts = svn_hash__get_bool(fs->config, SVN_FS_CONFIG_FSFS_CACHE_FULLTEXTS, TRUE); /* don't cache revprops by default. * Revprop caching significantly speeds up operations like * svn ls -v. However, it requires synchronization that may * not be available or efficient in the current server setup. * * If the caller chose option "2", enable revprop caching if * the required API support is there to make it efficient. */ if (strcmp(svn_hash__get_cstring(fs->config, SVN_FS_CONFIG_FSFS_CACHE_REVPROPS, ""), "2")) *cache_revprops = svn_hash__get_bool(fs->config, SVN_FS_CONFIG_FSFS_CACHE_REVPROPS, FALSE); else *cache_revprops = svn_named_atomic__is_efficient(); return svn_config_get_bool(ffd->config, fail_stop, CONFIG_SECTION_CACHES, CONFIG_OPTION_FAIL_STOP, FALSE); }