private static Dbenv CreateEnv(EnvConfig envConfig)
{
BDbOffsetOf offsetOf = BDbOffsetOfReader.ReadXmlFile();
BDbOffsetOfInstance.SetInstance(offsetOf);
IntPtr pdbenv;
BerkeleyDbError error = BDbenvMethods.Create(offsetOf, out pdbenv);
if (error != 0)
{
throw new InvalidOperationException("db_env_create error " + BDbenvMethods.StrError(error));
}
BDbenvMethods methods = BDbenvMethods.GetMethods();
error = methods.Open(pdbenv, envConfig.DbHome, envConfig.OpenFlags);
if (error == BerkeleyDbError.ENOENT && envConfig.UseTempIfFault)
{
String dbHome = Path.Combine(Path.GetTempPath(), "berkeley_db_home");
Directory.CreateDirectory(dbHome);
error = methods.Open(pdbenv, dbHome, envConfig.OpenFlags);
}
if (error != 0)
{
methods.Close(pdbenv, 0);
throw new InvalidOperationException("DB_ENV->open error " + BDbenvMethods.StrError(error));
}
return(new Dbenv(pdbenv, methods));
}
public static JToken CreateJTokenObject(BerkeleyDbError error, Byte[] key, Byte[] value, int keySize, int valueSize)
{
using (var jsonWriter = new JTokenWriter())
{
jsonWriter.WriteStartObject();
if (error != 0)
{
jsonWriter.WritePropertyName("ErrorCode");
jsonWriter.WriteValue((int)error);
}
if (key != null)
{
jsonWriter.WritePropertyName("Key");
String base64 = Convert.ToBase64String(key, 0, keySize);
jsonWriter.WriteValue(base64);
}
if (value != null)
{
jsonWriter.WritePropertyName("Value");
String base64 = Convert.ToBase64String(value, 0, valueSize);
jsonWriter.WriteValue(base64);
}
jsonWriter.WriteEndObject();
return(jsonWriter.Token);
}
}
public override async Task <BerkeleyError> WriteMultipleAsync(BerkeleyDb db, BerkeleyDtoPut data, BerkeleyDbWriteMode writeMode)
{
String requestUri;
ObjectContent content;
if (data.Key == null)
{
requestUri = "api/database/writemultiplekey/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
content = new ObjectContent <Byte[]>(data.Value, _formatter, (String)null);
}
else
{
requestUri = "api/database/write/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
content = new ObjectContent <BerkeleyDtoPut>(data, _formatter, (String)null);
}
HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content);
if (!response.IsSuccessStatusCode)
{
return(new BerkeleyError(response.StatusCode));
}
BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);
return(new BerkeleyError(error));
}
public override async Task <BerkeleyError> WriteDuplicateAsync(BerkeleyDb db, BerkeleyDtoPut data, int bufferSize, BerkeleyDbWriteMode writeMode)
{
String requestUri;
BerkeleyDtoPut dataPost;
if (data.Key.Length <= bufferSize && data.Value.Length <= bufferSize)
{
requestUri = "api/database/writemultipleduplicate/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
dataPost = new BerkeleyDtoPut(data.Key, data.Value);
}
else
{
requestUri = "api/database/write/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
dataPost = data;
}
ObjectContent content = new ObjectContent <BerkeleyDtoPut>(dataPost, _formatter, (String)null);
HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(new BerkeleyError(response.StatusCode));
}
BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);
return(new BerkeleyError(error));
}
public JToken Read([FromUri] ulong handle, [FromUri] BerkeleyDbOperation operation, [FromUri] BerkeleyDbMultiple multiple, [FromUri] int size, [FromBody] Byte[] key)
{
DbcHandle dbc = GetDbc(handle);
if (key == null)
{
key = new Byte[size];
}
Byte[] value = new Byte[size];
int keySize, valueSize;
BerkeleyDbError error = dbc.Methods.Get(dbc.Handle, key, value, operation, multiple, out keySize, out valueSize);
if (error == BerkeleyDbError.DB_BUFFER_SMALL)
{
if (key.Length < keySize)
{
key = new Byte[keySize];
}
if (value.Length < valueSize)
{
value = new Byte[valueSize];
}
error = dbc.Methods.Get(dbc.Handle, key, value, operation, multiple, out keySize, out valueSize);
}
return(ControllersHelper.CreateJTokenObject(error, key, value, keySize, valueSize));
}
public static JToken CreateJTokenObject(BerkeleyDbError error, Byte[] key, Byte[] value, int keySize, int valueSize)
{
using (var jsonWriter = new JTokenWriter())
{
jsonWriter.WriteStartObject();
if (error != 0)
{
jsonWriter.WritePropertyName("ErrorCode");
jsonWriter.WriteValue((int)error);
}
if (key != null)
{
jsonWriter.WritePropertyName("Key");
String base64 = Convert.ToBase64String(key, 0, keySize);
jsonWriter.WriteValue(base64);
}
if (value != null)
{
jsonWriter.WritePropertyName("Value");
String base64 = Convert.ToBase64String(value, 0, valueSize);
jsonWriter.WriteValue(base64);
}
jsonWriter.WriteEndObject();
return jsonWriter.Token;
}
}
public BerkeleyDtoResult PageSize([FromUri] ulong handle)
{
uint pageSize;
DbHandle db = GetDb(handle);
BerkeleyDbError error = db.Methods.GetPageSize(db.Handle, out pageSize);
return(new BerkeleyDtoResult(error, pageSize.ToString()));
}
public static BerkeleyDbError Create(BDbOffsetOf offsetOf, IntPtr pdb, BerkeleyDbType dbType, BerkeleyDbCursorFlags flags, out IntPtr pdbc)
{
BDbMethods dbMethods = BDbMethods.GetMethods(dbType);
BerkeleyDbError error = dbMethods.Cursor(pdb, flags, out pdbc);
if (error == 0)
{
CreateMethods(dbType, pdbc, offsetOf);
}
return(error);
}
public override String ToString()
{
if (BerkeleyDbError == 0)
{
return("HttpStatusCode = " + HttpStatusCode.ToString());
}
else
{
return("BerkeletDbError = " + BerkeleyDbError.ToString());
}
}
public override async Task <BerkeleyError> CloseDbAsync(BerkeleyDb db, BerkeleyDbClose flags)
{
String requestUri = "api/database/close/?handle=" + db.Handle.ToString() + "&flags=" + flags.ToStringEx();
HttpResponseMessage response = await _httpClient.GetAsync(requestUri).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(new BerkeleyError(response.StatusCode));
}
BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);
return(new BerkeleyError(error));
}
public override async Task <BerkeleyError> DeleteAsync(BerkeleyDb db, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple)
{
String requestUri = "api/database/delete/?handle=" + db.Handle.ToString() + "&flag=" + flag.ToStringEx() + "&multiple=" + multiple.ToStringEx();
var content = new ObjectContent <Byte[]>(key, _formatter, (String)null);
HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(new BerkeleyError(response.StatusCode));
}
BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);
return(new BerkeleyError(error));
}
public BerkeleyDtoResult OpenCursor([FromUri] ulong handle, [FromUri] String flags)
{
DbHandle db = GetDb(handle);
BerkeleyDbCursorFlags cursorFlags = flags == null ? 0 : BerkeleyEnumParser.CursorFlags(flags);
ulong cursorHandle = 0;
IntPtr pdbc;
BerkeleyDbError error = BDbcMethods.Create(BDbOffsetOfInstance.Instance, db.Handle, db.Methods.DbType, cursorFlags, out pdbc);
if (error == 0)
{
DbcHandle dbc = new DbcHandle(pdbc, BDbcMethods.GetMethods(db.Methods.DbType));
cursorHandle = DbcInstance.AddDbc(dbc);
if (cursorHandle == 0)
{
dbc.Methods.Close(dbc.Handle);
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
return(new BerkeleyDtoResult(error, cursorHandle.ToString()));
}
public BerkeleyDtoResult Create([FromUri] BerkeleyDbType type, [FromUri] String flags)
{
ulong handle = 0;
BerkeleyDbFlags bdbFlags = BerkeleyEnumParser.Flags(flags);
IntPtr pdb;
IntPtr penv = DbenvInstance.Instance.Handle;
BerkeleyDbError error = BDbMethods.Create(BDbOffsetOfInstance.Instance, penv, type, bdbFlags, out pdb);
if (error == 0)
{
BDbMethods dbMethods = BDbMethods.GetMethods(type);
var db = new DbHandle(pdb, dbMethods);
handle = DbInstance.AddDb(db);
if (handle == 0)
{
dbMethods.Close(pdb, 0);
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
return(new BerkeleyDtoResult(error, handle.ToString()));
}
public BerkeleyDtoResult(BerkeleyDbError error, String result)
{
Error = error;
Result = result;
}
public static String StrError(BerkeleyDbError error)
{
return db_strerror((int)error);
}
public static String StrError(BerkeleyDbError error)
{
return(db_strerror((int)error));
}
public BerkeleyDtoResult(BerkeleyDbError error, String result)
{
Error = error;
Result = result;
}
public BerkeleyException(HttpStatusCode httpStatusCode, BerkeleyDbError berkeleyDbError)
{
_httpStatusCode = httpStatusCode;
_berkeleyDbError = berkeleyDbError;
}
public BerkeleyError(HttpStatusCode httStatusCode, BerkeleyDbError berkeleyDbError)
{
_httStatusCode = httStatusCode;
_berkeleyDbError = berkeleyDbError;
}
public BerkeleyError(BerkeleyDbError berkeleyDbError)
: this(HttpStatusCode.OK, berkeleyDbError)
{
}
public BerkeleyResult(BerkeleyDbError berkeleyDbError, T result)
{
_error = new BerkeleyError(berkeleyDbError);
_result = result;
}
public BerkeleyResult(BerkeleyDbError berkeleyDbError)
{
_error = new BerkeleyError(berkeleyDbError);
_result = default(T);
}
