private ObsException ParseObsException(HttpResponse response, string message, Exception ex, HttpContext context)
{
ObsException exception = new ObsException(message, ex);
if (response != null)
{
exception.StatusCode = response.StatusCode;
string temp;
try
{
if (response.Content.Length > 0)
{
CommonParser.ParseErrorResponse(response.Content, exception);
}
else if (response.Headers.ContainsKey(Constants.ObsHeadErrorCode) && response.Headers.ContainsKey(Constants.ObsHeadErrorMessage))
{
response.Headers.TryGetValue(Constants.ObsHeadErrorCode, out temp);
exception.ErrorCode = temp;
response.Headers.TryGetValue(Constants.ObsHeadErrorMessage, out temp);
exception.ErrorMessage = temp;
}
else
{
exception.ErrorCode = response.StatusCode.ToString();
exception.ErrorMessage = response.Failure.Message;
}
}
catch (Exception ee)
{
exception.ErrorMessage = ee.Message;
if (LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error(ee.Message, ee);
}
}
if (response.Headers.TryGetValue(this.GetIHeaders(context).RequestId2Header(), out temp))
{
exception.ObsId2 = temp;
}
if (string.IsNullOrEmpty(exception.RequestId) && response.Headers.TryGetValue(this.GetIHeaders(context).RequestIdHeader(), out temp))
{
exception.RequestId = temp;
}
response.Abort();
}
exception.ErrorType = ErrorType.Receiver;
return(exception);
}
internal void init(string accessKeyId, string secretAccessKey, string securityToken, ObsConfig obsConfig)
{
if (obsConfig == null || string.IsNullOrEmpty(obsConfig.Endpoint))
{
throw new ObsException(Constants.InvalidEndpointMessage, ErrorType.Sender, Constants.InvalidEndpoint, "");
}
SecurityProvider sp = new SecurityProvider();
sp.Ak = accessKeyId;
sp.Sk = secretAccessKey;
sp.Token = securityToken;
this.sp = sp;
this.ObsConfig = obsConfig;
this.httpClient = new HttpClient(this.ObsConfig);
if (this.ObsConfig.PathStyle)
{
this.ObsConfig.AuthTypeNegotiation = false;
if (this.ObsConfig.AuthType == AuthTypeEnum.OBS)
{
this.ObsConfig.AuthType = AuthTypeEnum.V2;
}
}
if (this.ObsConfig.AuthTypeNegotiation)
{
this.locksHolder = new LocksHolder();
authTypeCache = new AuthTypeCache();
}
LoggerMgr.Initialize();
if (LoggerMgr.IsWarnEnabled)
{
StringBuilder sb = new StringBuilder();
sb.Append("[OBS SDK Version=")
.Append(Constants.ObsSdkVersion)
.Append("];[")
.Append("Endpoint=")
.Append(obsConfig.Endpoint)
.Append("];[")
.Append("Access Mode=")
.Append(obsConfig.PathStyle ? "Path" : "Virtual Hosting")
.Append("]");
LoggerMgr.Warn(sb.ToString());
}
}
public static long?ParseToInt64(string value)
{
try
{
return(string.IsNullOrEmpty(value) ? (long?)null : Convert.ToInt64(value));
}
catch (Exception ex)
{
if (LoggerMgr.IsWarnEnabled)
{
LoggerMgr.Warn(string.Format("Parse {0} to Int64 failed", value), ex);
}
return(null);
}
}
/// <summary>
/// Write the object content to a file.
/// </summary>
/// <param name="filePath">File path</param>
/// <param name="append">Write mode</param>
public void WriteResponseStreamToFile(string filePath, bool append)
{
try
{
filePath = System.IO.Path.GetFullPath(filePath);
FileInfo fi = new FileInfo(filePath);
Directory.CreateDirectory(fi.DirectoryName);
FileMode fm = FileMode.Create;
if (append && File.Exists(filePath))
{
fm = FileMode.Append;
}
using (Stream downloadStream = new FileStream(filePath, fm, FileAccess.Write, FileShare.Read, Constants.DefaultBufferSize))
{
long current = 0;
byte[] buffer = new byte[Constants.DefaultBufferSize];
int bytesRead = 0;
while ((bytesRead = this.OutputStream.Read(buffer, 0, buffer.Length)) > 0)
{
downloadStream.Write(buffer, 0, bytesRead);
current += bytesRead;
}
if (current != this.ContentLength)
{
throw new ObsException(string.Format("The total bytes read {0} from response stream is not equal to the Content-Length {1}", current, this.ContentLength), ErrorType.Receiver, null);
}
}
}
catch (ObsException ex)
{
if (LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error(ex.Message, ex);
}
throw ex;
}
catch (Exception ex)
{
if (LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error(ex.Message, ex);
}
ObsException exception = new ObsException(ex.Message, ex);
exception.ErrorType = ErrorType.Receiver;
throw exception;
}
}
public static void CloseIDisposable(IDisposable disposable)
{
if (disposable != null)
{
try
{
disposable.Dispose();
}
catch (Exception ee)
{
if (LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error(ee.Message, ee);
}
}
}
}
/// <summary>
/// Save Order deatils
/// </summary>
/// <param name="_orderInfo"></param>
/// <returns></returns>
public int SaveOrders(OrdersEntity _orderInfo)
{
try
{
int _response = context.SaveOrderlist(_orderInfo);
if (_response > 0)
{
EmailService _email = new EmailService();
_email.SendEmail(_orderInfo.BuyerInfoDetail.Email.ToStr());
}
return(_response);
}
catch (Exception ex)
{
LoggerMgr.Web.Error(LoggerMgr.GetErrorMessageRootText(DataHelper.Layer.BusinessServiceLayer, DataHelper.BusinessServices.OrdersManager, MethodBase.GetCurrentMethod().Name), ex);
throw;
}
}
public static void WriteTo(Stream src, Stream dest, int bufferSize, ObsCallback callback)
{
DateTime reqTime = DateTime.Now;
byte[] buffer = new byte[bufferSize];
int bytesRead;
while ((bytesRead = src.Read(buffer, 0, buffer.Length)) > 0)
{
dest.Write(buffer, 0, bytesRead);
callback?.Invoke();
}
dest.Flush();
if (LoggerMgr.IsInfoEnabled)
{
LoggerMgr.Info(string.Format("Write http request stream end, cost {0} ms", (DateTime.Now.Ticks - reqTime.Ticks) / 10000));
}
}
public IHttpActionResult GetAllOrders()
{
try
{
List <OrdersEntity> _orderList = new OrdersManager().GetAllOrders();
if (_orderList.Count > 0)
{
return(Ok(_orderList));
}
else
{
return(NotFound());
}
}
catch (Exception ex)
{
LoggerMgr.Web.Error(LoggerMgr.GetErrorMessageRootText(DataHelper.Layer.WebApiLayer, DataHelper.ApiControllers.Orders, MethodInfo.GetCurrentMethod().Name), ex);
throw;
}
}
public IHttpActionResult UpdateOrders(OrdersEntity _orderInfo)
{
try
{
int _res = new OrdersManager().UpdateOrders(_orderInfo);
if (_res > 0)
{
return(Ok());
}
else
{
return(BadRequest("Invalid data entry."));
}
}
catch (Exception ex)
{
LoggerMgr.Web.Error(LoggerMgr.GetErrorMessageRootText(DataHelper.Layer.WebApiLayer, DataHelper.ApiControllers.Orders, MethodInfo.GetCurrentMethod().Name), ex);
throw;
}
}
internal static HttpWebRequest BuildWebRequest(HttpRequest request, HttpContext context)
{
if (LoggerMgr.IsDebugEnabled)
{
LoggerMgr.Debug("Perform http request with url:" + request.GetUrl());
}
string url = string.IsNullOrEmpty(context.RedirectLocation) ? request.GetUrl() : context.RedirectLocation;
ObsConfig obsConfig = context.ObsConfig;
HttpWebRequest webRequest = WebRequest.Create(url) as HttpWebRequest;
AddHeaders(webRequest, request, obsConfig);
AddProxy(webRequest, obsConfig);
if (webRequest.RequestUri.Scheme.Equals("https") && !obsConfig.ValidateCertificate)
{
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(ValidateCertificate);
}
return(webRequest);
}
public static DateTime?ParseToDateTime(string value, string format1, string format2)
{
try
{
return(string.IsNullOrEmpty(value) ? (DateTime?)null : DateTime.ParseExact(value, format1, Constants.CultureInfo));
}
catch (Exception)
{
try
{
return(DateTime.ParseExact(value, format2, Constants.CultureInfo));
}
catch (Exception ex)
{
if (LoggerMgr.IsWarnEnabled)
{
LoggerMgr.Warn(string.Format("Parse {0} to DateTime failed", value), ex);
}
return(null);
}
}
}
private void PrepareRetry(HttpRequest request, HttpResponse response, int retryCount, long originPos, bool sleep)
{
CommonUtil.CloseIDisposable(response);
if (request.Content != null && (originPos >= 0 && request.Content.CanSeek))
{
request.Content.Seek(originPos, SeekOrigin.Begin);
if (request.Content is TransferStream)
{
(request.Content as TransferStream).ResetReadProgress();
}
}
if (sleep)
{
int delay = (int)Math.Pow(2, retryCount) * 50;
if (LoggerMgr.IsWarnEnabled)
{
LoggerMgr.Warn(string.Format("Send http request error, will retry in {0} ms", delay));
}
Thread.Sleep(delay);
}
}
/// <summary>
/// Delete Order id
/// </summary>
/// <param name="_orderId"></param>
/// <returns></returns>
public int DeleteOrderId(int _orderId)
{
int result = 0;
using (var dao = DbActivity.Open())
{
try
{
CSqlDbCommand cmd = new CSqlDbCommand(DataHelper.DBCommands.USP_DELETE_ORDER);
cmd.Parameters.AddWithValue("OrderId", _orderId);
result = dao.ExecCommand(cmd);
dao.Commit();
}
catch (Exception ex)
{
dao.Rollback();
LoggerMgr.Web.Error(LoggerMgr.GetErrorMessageRootText(DataHelper.Layer.DataAccessLayer, DataHelper.DataAccess.OrdersContext, MethodInfo.GetCurrentMethod().Name), ex);
throw;
}
return(result);
}
}
/// <summary>
/// Get Orderlist
/// </summary>
/// <returns></returns>
public List <OrdersEntity> GetAllOrders(int?_orderId)
{
List <OrdersEntity> _ordersEntity = new List <OrdersEntity>();
try
{
using (var dao = DbActivity.Open())
{
CSqlDbCommand cmd = new CSqlDbCommand(DataHelper.DBCommands.USP_GET_ORDERLIST);
cmd.Parameters.AddWithValue("OrderId", _orderId);
dao.ExecReader(cmd);
while (dao.DataReader.Read())
{
_ordersEntity.Add(new OrdersEntity()
{
OrderId = dao.DataReader["OrderId"].ToInt(),
BuyerId = dao.DataReader["BuyerId"].ToInt(),
OrderStatus = dao.DataReader["Status_Code"].ToStr(),
BuyerInfoDetail = new BuyerEntity()
{
BuyerId = dao.DataReader["BuyerId"].ToInt(),
LastName = dao.DataReader["LastName"].ToStr(),
FirstName = dao.DataReader["FirstName"].ToStr(),
PhoneNumber = dao.DataReader["Mobile"].ToStr(),
Email = dao.DataReader["Email"].ToStr(),
Address = dao.DataReader["Address"].ToStr()
},
ProductInfoDetail = GetProductDetails(dao.DataReader["OrderId"].ToInt())
});
}
}
}
catch (Exception ex)
{
LoggerMgr.Web.Error(LoggerMgr.GetErrorMessageRootText(DataHelper.Layer.DataAccessLayer, DataHelper.DataAccess.OrdersContext, MethodInfo.GetCurrentMethod().Name), ex);
throw;
}
return(_ordersEntity);
}
public void Run(string[] args)
{
Console.WriteLine("Core/Log/Logger test:");
string logCfg = "Logger_Cfg.cfg";
LoggerMgr.Init(logCfg);
// Test Root logger.
Log.enabledLogFileInfo = true;
Log.Dbg("A debug message from Log.Dbg()...");
Log.Info("A info message from Log.Info()...");
Log.Warn("A warn message from Log.Warn()...");
Log.Err("A error message from Log.Err()...");
Log.Fatal("A fatal message from Log.Fatal()...");
Log.Dbg <Log>("A debug message from Log.Dbg<Log>()...");
Log.Info <Log>("A debug message from Log.Dbg<Log>()...");
Log.Warn <Log>("A debug message from Log.Dbg<Log>()...");
Log.Err <Log>("A debug message from Log.Dbg<Log>()...");
Log.Fatal <Log>("A debug message from Log.Dbg<Log>()...");
// Get test logger to test.
var testLogger = LoggerMgr.Get("test");
testLogger.Dbg("A debug message from testLogger.Dbg()...");
testLogger.Info("A info message from testLogger.Info()...");
testLogger.Warn("A warn message from testLogger.Warn()...");
testLogger.Err("A error message from testLogger.Err()...");
testLogger.Fatal("A fatal message from testLogger.Fatal()...");
Console.WriteLine("Press any key to exit test...");
Console.ReadKey();
LoggerMgr.Destroy();
}
internal AuthTypeEnum?NegotiateAuthType(string bucketName, bool async)
{
AuthTypeEnum? authType = AuthTypeEnum.V2;
GetApiVersionRequest request = new GetApiVersionRequest();
request.BucketName = bucketName;
try
{
GetApiVersionResponse response = async ? this.GetApiVersionAsync(request) : this.GetApiVersion(request);
if (response.StatusCode == HttpStatusCode.OK)
{
if ((response.Headers.ContainsKey(Constants.ObsApiHeader) &&
response.Headers[Constants.ObsApiHeader].CompareTo("3.0") >= 0) || (response.Headers.ContainsKey(Constants.ObsApiHeaderWithPrefix) &&
response.Headers[Constants.ObsApiHeaderWithPrefix].CompareTo("3.0") >= 0))
{
authType = AuthTypeEnum.OBS;
}
}
}
catch (ObsException ex)
{
int statusCode = Convert.ToInt32(ex.StatusCode);
if (statusCode <= 0 || statusCode == 404 || statusCode >= 500)
{
throw ex;
}
if (LoggerMgr.IsInfoEnabled)
{
string msg = string.IsNullOrEmpty(bucketName) ? "The target server doesnot support OBS protocol, use S3 protocol" : string.Format("The target server doesnot support OBS protocol, use S3 protocol, Bucket:{0}", bucketName);
LoggerMgr.Info(msg, ex);
}
}
return(authType);
}
internal K DoRequest <T, K>(T request, DoValidateDelegate doValidateDelegate)
where T : ObsWebServiceRequest
where K : ObsWebServiceResponse
{
HttpContext context = this.BeforeRequest(request, doValidateDelegate, false);
DateTime reqTime = DateTime.Now;
HttpRequest httpRequest = null;
try
{
httpRequest = this.PrepareHttpRequest(request, context);
HttpResponse httpResponse = this.httpClient.PerformRequest(httpRequest, context);
return(PrepareResponse <T, K>(request, context, httpRequest, httpResponse));
}
catch (ObsException ex)
{
if ("CreateBucket".Equals(request.GetAction()) &&
ex.StatusCode == HttpStatusCode.BadRequest &&
"Unsupported Authorization Type".Equals(ex.ErrorMessage) &&
this.ObsConfig.AuthTypeNegotiation &&
context.AuthType == AuthTypeEnum.OBS)
{
try
{
if (httpRequest.Content != null && httpRequest.Content.CanSeek)
{
httpRequest.Content.Seek(0, SeekOrigin.Begin);
}
context.AuthType = AuthTypeEnum.V2;
return(PrepareResponse <T, K>(request, context, httpRequest, this.httpClient.PerformRequest(httpRequest, context)));
}catch (ObsException _ex)
{
if (LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error(string.Format("{0} exception code: {1}, with message: {2}", request.GetAction(), _ex.ErrorCode, _ex.Message));
}
throw _ex;
}
catch (Exception _ex)
{
if (LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error(string.Format("{0} exception with message: {1}", request.GetAction(), _ex.Message));
}
throw new ObsException(_ex.Message, _ex);
}
}
if (LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error(string.Format("{0} exception code: {1}, with message: {2}", request.GetAction(), ex.ErrorCode, ex.Message));
}
throw ex;
}
catch (Exception ex)
{
if (LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error(string.Format("{0} exception with message: {1}", request.GetAction(), ex.Message));
}
throw new ObsException(ex.Message, ex);
}
finally
{
if (request != null)
{
request.Sender = null;
}
CommonUtil.CloseIDisposable(httpRequest);
if (LoggerMgr.IsInfoEnabled)
{
LoggerMgr.Info(string.Format("{0} end, cost {1} ms", request.GetAction(), (DateTime.Now - reqTime).TotalMilliseconds));
}
}
}
private HttpContext BeforeRequest <T>(T request, DoValidateDelegate doValidateDelegate, bool async) where T : ObsWebServiceRequest
{
if (request == null)
{
throw new ObsException(Constants.NullRequestMessage, ErrorType.Sender, Constants.NullRequest, "");
}
HttpContext context = new HttpContext(this.sp, this.ObsConfig);
if (request is GetApiVersionRequest)
{
context.SkipAuth = true;
}
else
{
ObsBucketWebServiceRequest _request = request as ObsBucketWebServiceRequest;
if (_request != null && string.IsNullOrEmpty(_request.BucketName))
{
throw new ObsException(Constants.InvalidBucketNameMessage, ErrorType.Sender, Constants.InvalidBucketName, "");
}
if (this.ObsConfig.AuthTypeNegotiation)
{
AuthTypeEnum?authType;
if (_request == null)
{
//list buckets
authType = this.NegotiateAuthType(null, async);
}
else
{
if ((authType = this.authTypeCache.GetAuthType(_request.BucketName)) == null)
{
lock (this.locksHolder.GetLock(_request.BucketName))
{
if ((authType = this.authTypeCache.GetAuthType(_request.BucketName)) == null)
{
if (request is CreateBucketRequest)
{
authType = this.NegotiateAuthType(null, async);
}
else
{
authType = this.NegotiateAuthType(_request.BucketName, async);
this.authTypeCache.RefreshAuthType(_request.BucketName, authType.Value);
if (LoggerMgr.IsInfoEnabled)
{
LoggerMgr.Info(string.Format("Refresh auth type {0} for bucket {1}", authType, _request.BucketName));
}
}
}
}
}
}
if (LoggerMgr.IsDebugEnabled)
{
LoggerMgr.Debug(string.Format("Get auth type {0}", authType));
}
context.AuthType = authType;
}
}
request.Sender = this;
doValidateDelegate?.Invoke();
if (LoggerMgr.IsInfoEnabled)
{
LoggerMgr.Info(request.GetAction() + " begin.");
}
return(context);
}
internal HttpResponse PerformRequest(HttpRequest request, HttpContext context, int retryCount)
{
long originPos = -1;
HttpResponse response = null;
try
{
if (request.Content != null && request.Content.CanSeek)
{
originPos = request.Content.Position;
}
response = this.DoRequest(request, context);
new MergeResponseHeaderHandler(this.GetIHeaders(context)).Handle(response);
int statusCode = Convert.ToInt32(response.StatusCode);
if (LoggerMgr.IsDebugEnabled)
{
LoggerMgr.Debug(string.Format("Response with statusCode {0} and headers {1}", statusCode, CommonUtil.ConvertHeadersToString(response.Headers)));
}
int maxErrorRetry = context.ObsConfig.MaxErrorRetry;
if (statusCode >= 300 && statusCode < 400 && statusCode != 304)
{
if (response.Headers.ContainsKey(Constants.CommonHeaders.Location))
{
string location = response.Headers[Constants.CommonHeaders.Location];
if (!string.IsNullOrEmpty(location))
{
if (location.IndexOf("?") < 0)
{
location += "?" + CommonUtil.ConvertParamsToString(request.Params);
}
if (LoggerMgr.IsWarnEnabled)
{
LoggerMgr.Warn(string.Format("Redirect to {0}", location));
}
context.RedirectLocation = location;
retryCount--;
if (ShouldRetry(request, null, retryCount, maxErrorRetry))
{
PrepareRetry(request, response, retryCount, originPos, false);
return(PerformRequest(request, context, ++retryCount));
}
else if (retryCount > maxErrorRetry)
{
throw ParseObsException(response, "Exceeded 3xx redirect limit", context);
}
}
}
throw ParseObsException(response, "Try to redirect, but location is null!", context);
}
else if ((statusCode >= 400 && statusCode < 500) || statusCode == 304)
{
ObsException exception = ParseObsException(response, "Request error", context);
if (Constants.RequestTimeout.Equals(exception.ErrorCode))
{
if (ShouldRetry(request, null, retryCount, maxErrorRetry))
{
if (LoggerMgr.IsWarnEnabled)
{
LoggerMgr.Warn("Retrying connection that failed with RequestTimeout error");
}
PrepareRetry(request, response, retryCount, originPos, false);
return(PerformRequest(request, context, ++retryCount));
}
else if (retryCount > maxErrorRetry && LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error("Exceeded maximum number of retries for RequestTimeout errors");
}
}
throw exception;
}
else if (statusCode >= 500)
{
if (ShouldRetry(request, null, retryCount, maxErrorRetry))
{
PrepareRetry(request, response, retryCount, originPos, true);
return(PerformRequest(request, context, ++retryCount));
}
else if (retryCount > maxErrorRetry && LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error("Encountered too many 5xx errors");
}
throw ParseObsException(response, "Request error", context);
}
return(response);
}
catch (Exception ex)
{
try
{
if (ex is ObsException)
{
if (LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error("Rethrowing as a ObsException error in PerformRequest", ex);
}
throw ex;
}
else
{
if (ShouldRetry(request, ex, retryCount, context.ObsConfig.MaxErrorRetry))
{
PrepareRetry(request, response, retryCount, originPos, true);
return(PerformRequest(request, context, ++retryCount));
}
else if (retryCount > context.ObsConfig.MaxErrorRetry && LoggerMgr.IsWarnEnabled)
{
LoggerMgr.Warn("Too many errors excced the max error retry count", ex);
}
if (LoggerMgr.IsErrorEnabled)
{
LoggerMgr.Error("Rethrowing as a ObsException error in PerformRequest", ex);
}
throw ParseObsException(response, ex.Message, ex, context);
}
}
finally
{
CommonUtil.CloseIDisposable(response);
}
}
}
internal static string GetTemporarySignature(HttpRequest request, HttpContext context, IHeaders iheaders, IDictionary <string, string> dateDict, string signedHeaders,
IDictionary <string, string> headerDict, List <string> signedHeaderList, string payload)
{
StringBuilder canonicalRequest = new StringBuilder();
canonicalRequest.Append(request.Method).Append("\n");
// Canonical URI
canonicalRequest.Append("/");
if (!string.IsNullOrEmpty(request.BucketName))
{
if (request.PathStyle)
{
canonicalRequest.Append(CommonUtil.UrlEncode(request.BucketName));
}
if (!string.IsNullOrEmpty(request.ObjectKey))
{
if (request.PathStyle)
{
canonicalRequest.Append("/");
}
canonicalRequest.Append(CommonUtil.UrlEncode(request.ObjectKey, null, "/"));
}
}
canonicalRequest.Append("\n");
//CanonicalQueryString
IDictionary <string, string> tempDict = new Dictionary <string, string>();
foreach (KeyValuePair <string, string> entry in request.Params)
{
if (string.IsNullOrEmpty(entry.Key))
{
continue;
}
tempDict.Add(entry.Key, entry.Value);
}
List <KeyValuePair <string, string> > kvlist = new List <KeyValuePair <string, string> >(tempDict);
tempDict.Clear();
kvlist.Sort(delegate(KeyValuePair <string, string> x, KeyValuePair <string, string> y)
{
return(string.Compare(x.Key, y.Key, StringComparison.Ordinal));
});
canonicalRequest.Append(CommonUtil.ConvertParamsToCanonicalQueryString(kvlist));
canonicalRequest.Append("\n");
if (headerDict == null)
{
// Canonical Headers
headerDict = new Dictionary <string, string>();
foreach (KeyValuePair <string, string> entry in request.Headers)
{
if (string.IsNullOrEmpty(entry.Key))
{
continue;
}
headerDict.Add(entry.Key.Trim().ToLower(), entry.Value);
}
}
foreach (string key in signedHeaderList)
{
canonicalRequest.Append(key).Append(":").Append(headerDict[key]).Append("\n");
}
canonicalRequest.Append("\n");
// SignedHeaders
canonicalRequest.Append(signedHeaders);
canonicalRequest.Append("\n");
// Hashed Payload
canonicalRequest.Append(string.IsNullOrEmpty(payload)? UnsignedPayload : payload);
if (LoggerMgr.IsDebugEnabled)
{
LoggerMgr.Debug("CanonicalRequest:" + canonicalRequest);
}
StringBuilder stringToSign = new StringBuilder(Algorithm).Append("\n")
.Append(dateDict["LongDate"]).Append("\n")
.Append(dateDict["ShortDate"]).Append(ScopeSuffix).Append("\n")
.Append(CommonUtil.HexSha256(canonicalRequest.ToString()));
if (LoggerMgr.IsDebugEnabled)
{
LoggerMgr.Debug("StringToSign:" + stringToSign.ToString());
}
return(CaculateSignature(stringToSign.ToString(), dateDict["ShortDate"], context.SecurityProvider.Sk));
}
internal override IDictionary <string, string> GetSignature(HttpRequest request, HttpContext context, IHeaders iheaders)
{
StringBuilder stringToSign = new StringBuilder();
stringToSign.Append(request.Method.ToString()).Append("\n");
string dateHeader = Constants.CommonHeaders.Date.ToLower();
string contentTypeHeader = Constants.CommonHeaders.ContentType.ToLower();
string contentMd5Header = Constants.CommonHeaders.ContentMd5.ToLower();
string headerPrefix = iheaders.HeaderPrefix();
string headerMetaPrefix = iheaders.HeaderMetaPrefix();
IDictionary <string, string> tempDict = new Dictionary <string, string>();
if (request.Headers.Count > 0)
{
foreach (KeyValuePair <string, string> entry in request.Headers)
{
if (string.IsNullOrEmpty(entry.Key))
{
continue;
}
string key = entry.Key.Trim().ToLower();
if (key.StartsWith(headerPrefix) || key.Equals(contentTypeHeader) || key.Equals(contentMd5Header))
{
tempDict.Add(key, entry.Value);
}
}
}
if (request.Headers.ContainsKey(dateHeader))
{
tempDict.Add(dateHeader, request.Headers[dateHeader]);
}
else
{
tempDict.Add(dateHeader, "");
}
if (!tempDict.ContainsKey(contentMd5Header))
{
tempDict.Add(contentMd5Header, "");
}
if (!tempDict.ContainsKey(contentTypeHeader))
{
tempDict.Add(contentTypeHeader, "");
}
List <KeyValuePair <string, string> > kvlist = new List <KeyValuePair <string, string> >(tempDict);
tempDict.Clear();
kvlist.Sort(delegate(KeyValuePair <string, string> x, KeyValuePair <string, string> y)
{
return(string.Compare(x.Key, y.Key, StringComparison.Ordinal));
});
foreach (KeyValuePair <string, string> kv in kvlist)
{
if (kv.Key.StartsWith(headerMetaPrefix))
{
stringToSign.Append(kv.Key).Append(":").Append(kv.Value.Trim());
}
else if (kv.Key.StartsWith(headerPrefix))
{
stringToSign.Append(kv.Key).Append(":").Append(kv.Value);
}
else
{
stringToSign.Append(kv.Value);
}
stringToSign.Append("\n");
}
kvlist.Clear();
stringToSign.Append("/");
if (!string.IsNullOrEmpty(request.BucketName))
{
stringToSign.Append(CommonUtil.UrlEncode(request.BucketName));
if (!request.PathStyle)
{
stringToSign.Append("/");
}
if (!string.IsNullOrEmpty(request.ObjectKey))
{
if (request.PathStyle)
{
stringToSign.Append("/");
}
stringToSign.Append(CommonUtil.UrlEncode(request.ObjectKey, null, "/"));
}
}
if (request.Params.Count > 0)
{
foreach (KeyValuePair <string, string> entry in request.Params)
{
if (string.IsNullOrEmpty(entry.Key))
{
continue;
}
if (Constants.AllowedResourceParameters.Contains(entry.Key.ToLower()) || entry.Key.ToLower().StartsWith(iheaders.HeaderPrefix()))
{
tempDict.Add(entry.Key, entry.Value);
}
}
}
kvlist = new List <KeyValuePair <string, string> >(tempDict);
tempDict.Clear();
kvlist.Sort(delegate(KeyValuePair <string, string> x, KeyValuePair <string, string> y)
{
return(string.Compare(x.Key, y.Key, StringComparison.Ordinal));
});
if (kvlist.Count > 0)
{
bool isFirst = true;
foreach (KeyValuePair <string, string> kv in kvlist)
{
if (isFirst)
{
stringToSign.Append("?");
isFirst = false;
}
else
{
stringToSign.Append("&");
}
stringToSign.Append(kv.Key);
if (kv.Value != null)
{
stringToSign.Append("=").Append(kv.Value);
}
}
}
if (LoggerMgr.IsDebugEnabled)
{
LoggerMgr.Debug("StringToSign: ******");
}
IDictionary <string, string> ret = new Dictionary <string, string>();
ret.Add("Signature", Convert.ToBase64String(CommonUtil.HmacSha1(context.SecurityProvider.Sk, stringToSign.ToString())));
return(ret);
}
void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
LoggerMgr.GetInstance().Regist(this);
}
public void OnWorkCompltedCallBack(object returnValue)
{
// Console.WriteLine("Completed:{0}", returnValue);
LoggerMgr.GetInstance().Notify(new Logger(EnumLoggerType.Normal, string.Format("线程:{0} 已完成", ++count)));
}
