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); }