public BucketInfo[] GetBucketLayoutInfo()
{
int count = m_BucketSizes.Count;
BucketInfo[] buckets = new BucketInfo[count];
for (int i = 0; i < count; i++)
{
int size = m_BucketSizes[i];
buckets[i].size = size;
buckets[i].usedSize = 0;
buckets[i].attributes = new VFXAttribute[size];
buckets[i].channels = new int[size];
}
foreach (var kvp in m_AttributeLayout)
{
var attrib = kvp.Key;
int size = VFXValue.TypeToSize(attrib.type);
int offset = kvp.Value.offset;
for (int i = 0; i < size; i++)
{
buckets[kvp.Value.bucket].attributes[i + offset] = attrib;
buckets[kvp.Value.bucket].channels[i + offset] = i;
buckets[kvp.Value.bucket].usedSize = Math.Max(buckets[kvp.Value.bucket].usedSize, i + offset + 1);
}
}
return(buckets);
}
/// <summary>
/// 上传文件
/// </summary>
/// <param name="stream">文件流</param>
/// <returns>Oss文件地址</returns>
private async Task <string> PutObject(Stream stream, string key, string mimeType)
{
var bucketInfo = BucketInfo.CreateByRegion(CommConstant.OssRegion, CommConstant.OssBucket);
var requestContent = new RequestContent
{
ContentType = RequestContentType.Stream,
StreamContent = stream,
MimeType = mimeType
};
var result = await _client.PutObjectAsync(bucketInfo, key, requestContent);
if (!result.IsSuccess)
{
var message = string.Format("ErrorMessage:{0}", result.ErrorMessage);
if (result.ErrorResult != null)
{
message += string.Format("{0}HostId:{1}{2}RequestId:{3}{4}Code:{5}{6}Message:{7}{8}", Environment.NewLine,
result.ErrorResult.HostId, Environment.NewLine,
result.ErrorResult.RequestId, Environment.NewLine,
result.ErrorResult.Code, Environment.NewLine,
result.ErrorResult.Message, Environment.NewLine
);
}
//LogHelper.WriteError(message, result.InnerException);
return(string.Empty);
}
return(key);
}
/// <summary>
/// Append对象
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="nextAppendPosition"></param>
/// <param name="file"></param>
/// <returns></returns>
public async Task <OssResult <AppentObjectResult> > AppendObject(BucketInfo bucket, string key,
long nextAppendPosition, RequestContent file)
{
var cmd = new AppendObjectCommand(_requestContext, bucket, key, nextAppendPosition, file);
return(await cmd.ExecuteAsync());
}
public PutObjectCommand(RequestContext requestContext, BucketInfo bucketInfo, string key, RequestContent requestContent, IDictionary <string, string> extraHeaders)
: base(requestContext, bucketInfo, key)
{
Bucket = bucketInfo;
RequestContent = requestContent;
ExtraHeaders = extraHeaders;
}
public BaseObjectCommand(RequestContext requestContext,
BucketInfo bucket,
string key) : base(requestContext)
{
Bucket = bucket;
Key = key;
}
public static string BuildCanonicalizedResource(BucketInfo bucket, string key, IDictionary <string, string> parameters)
{
var sb = new StringBuilder();
sb.Append(bucket.MakeResourcePathForSign(key));
if (parameters != null)
{
var parameterNames = parameters.Keys.Where(k => ParamtersToSign.Contains(k)).ToList();
if (parameterNames.Count > 0)
{
parameterNames.Sort();
var separator = '?';
foreach (var paramName in parameterNames)
{
sb.Append(separator);
sb.Append(paramName);
var paramValue = parameters[paramName];
if (!string.IsNullOrEmpty(paramValue))
{
sb.Append("=").Append(paramValue);
}
separator = '&';
}
}
}
return(sb.ToString());
}
/// <summary>
/// Sets the cache-control header.
/// </summary>
/// <param name="bucketInfo">The bucket info dictionary.</param>
/// <param name="value">The cache control values.</param>
public static void SetCacheControl(this BucketInfo bucketInfo, CacheControlHeaderValue value)
{
if (value != null)
{
bucketInfo.Add("Cache-Control", value.ToString());
}
}
public GetObjectCommand(
RequestContext requestContext,
BucketInfo bucket,
string key,
GetObjectParams parameters) : base(requestContext, bucket, key)
{
Params = parameters;
}
/// <summary>
/// 复制对象
/// </summary>
/// <param name="bucket"></param>
/// <param name="srcKey"></param>
/// <param name="targetBucket"></param>
/// <param name="targetKey"></param>
/// <param name="extraHeaders"></param>
/// <returns></returns>
public async Task <OssResult <CopyObjectResult> > CopyObjectAsync(BucketInfo bucket, string srcKey,
BucketInfo targetBucket,
string targetKey,
IDictionary <string, string> extraHeaders = null)
{
var cmd = new CopyObjectCommand(_requestContext, targetBucket, targetKey, bucket, srcKey, extraHeaders);
return(await cmd.ExecuteAsync());
}
public AppendObjectCommand(RequestContext requestContext,
BucketInfo bucket,
string key,
long position,
RequestContent objectInfo) : base(requestContext, bucket, key)
{
Position = position;
RequestContent = objectInfo;
}
public override ServiceRequest BuildRequest()
{
var req = new ServiceRequest(BucketInfo.CreateByRegion(_region, ""), "", HttpMethod.Get);
req.AddParameter(RequestParameters.PREFIX, _request.Prefix);
req.AddParameter(RequestParameters.MARKER, _request.Marker);
req.AddParameter(RequestParameters.MAX_KEYS, _request.MaxKeys?.ToString());
return(req);
}
public DeleteMultipleObjectsCommand(RequestContext requestContext,
BucketInfo bucket,
IList <string> keys,
bool quiet = false,
string encodingType = "") : base(requestContext)
{
Bucket = bucket;
Keys = keys;
EncodingType = encodingType;
Quiet = quiet;
}
/// <summary>
/// 将指定的字符串内容上传为文件
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="content"></param>
/// <param name="mimeType"></param>
/// <returns></returns>
public async Task <OssResult <PutObjectResult> > PutObjectAsync(BucketInfo bucket, string key, string content, string mimeType = "text/plain")
{
var file = new RequestContent()
{
ContentType = RequestContentType.String,
StringContent = content,
MimeType = mimeType
};
return(await PutObjectAsync(bucket, key, file));
}
public void MaximumItems()
{
Assert.Throws <InvalidOperationException>(() =>
{
var list = new BucketInfo();
for (int i = 0; i < BucketInfo.MaximumBucketItemsAllowed + 1; i++)
{
list.Add(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
}
});
}
/// <summary>
/// 将指定的字符串内容上传为文件
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="content"></param>
/// <param name="mimeType"></param>
/// <returns></returns>
public async Task <OssResult <PutObjectResult> > PutObjectAsync(BucketInfo bucket, string key, string content, string mimeType = "text/plain", ObjectMetadata meta = null, IDictionary <string, string> extraHeaders = null)
{
var file = new RequestContent()
{
ContentType = RequestContentType.String,
StringContent = content,
MimeType = mimeType,
Metadata = meta
};
return(await PutObjectAsync(bucket, key, file, extraHeaders));
}
/// <summary>
/// 删除对象
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <returns></returns>
public async Task <OssResult <DeleteObjectResult> > DeleteObjectAsync(BucketInfo bucket, string key)
{
var cmd = new DeleteObjectCommand(_requestContext, bucket, key);
var result = await cmd.ExecuteAsync(_client);
if (!result.IsSuccess)
{
_logger.LogError($"Failed in OssClient.{nameof(PutObjectAsync)}(). \nBucket: {bucket.BucketName}\nPath: {key}");
}
return(result);
}
public void addBucket(BucketInfo info)
{
if (bucketMap == null)
{
bucketMap = new Dictionary <string, BucketInfo>();
}
BucketInfo temp;
if (bucketMap.TryGetValue(info.bucketName, out temp))
{
bucketMap.Remove(info.bucketName);
}
bucketMap.Add(info.bucketName, info);
}
/// <summary>
/// 根据指定的文件名上传文件
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="filePathName"></param>
/// <returns></returns>
public async Task <OssResult <PutObjectResult> > PutObjectByFileNameAsync(BucketInfo bucket, string key,
string filePathName)
{
using (var stream = File.OpenRead(filePathName))
{
var file = new RequestContent()
{
ContentType = RequestContentType.Stream,
StreamContent = stream,
MimeType = MimeHelper.GetMime(filePathName)
};
return(await PutObjectAsync(bucket, key, file));
}
}
public static async Task Main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Please run with bucket name and file path");
return;
}
var bucketName = args[0];
var filePath = args[1];
var conf = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", true, true)
.AddJsonFile("appsettings.Development.json", true, true)
.Build();
IServiceCollection services = new ServiceCollection();
services.AddOssClient(conf);
var sp = services.BuildServiceProvider();
var client = sp.GetService <OssClient>();
var bucket = BucketInfo.CreateByRegion(OssRegions.HangZhou, bucketName, false, false);
var remoteFilePaht = $"test/{DateTime.Now.ToString("yyyyMMddHHmmss")}.png";
using (var fs = new FileStream(filePath, FileMode.Open))
{
var file = new RequestContent()
{
MimeType = "images/png",
ContentType = RequestContentType.Stream,
StreamContent = fs,
};
var result = await client.PutObjectAsync(bucket, remoteFilePaht, file);
if (result.IsSuccess)
{
Console.WriteLine("Succeeded!");
}
else
{
Console.WriteLine("Failed!");
Console.WriteLine(result.ErrorMessage);
}
}
}
/// <summary>
/// 根据指定的文件名上传文件
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="filePathName"></param>
/// <returns></returns>
public async Task <OssResult <PutObjectResult> > PutObjectByFileNameAsync(BucketInfo bucket, string key,
string filePathName, ObjectMetadata meta = null, IDictionary <string, string> extraHeaders = null)
{
using (var stream = File.OpenRead(filePathName))
{
var file = new RequestContent()
{
ContentType = RequestContentType.Stream,
StreamContent = stream,
MimeType = MimeHelper.GetMime(filePathName),
Metadata = meta
};
return(await PutObjectAsync(bucket, key, file, extraHeaders));
}
}
public void BucketInfoEquatable()
{
var bucketinfo1 = new BucketInfo
{
{ "key1", "value1" },
{ "key2", "value2" }
};
var bucketinfo2 = new BucketInfo
{
{ "key1", "value1" },
{ "key2", "value2" }
};
Assert.True(bucketinfo1.Equals(bucketinfo2));
Assert.Equal(bucketinfo1.GetHashCode(), bucketinfo2.GetHashCode());
}
public void FileInfoEquatable()
{
var fileinfo1 = new BucketInfo
{
{ "key1", "value1" },
{ "key2", "value2" }
};
var fileinfo2 = new BucketInfo
{
{ "key1", "value1" },
{ "key2", "value2" }
};
Assert.True(fileinfo1.Equals(fileinfo2));
Assert.Equal(fileinfo1.GetHashCode(), fileinfo2.GetHashCode());
}
/// <summary>
/// 上传文件
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="file"></param>
/// <returns></returns>
public async Task <OssResult <PutObjectResult> > PutObjectAsync(BucketInfo bucket, string key, RequestContent file, IDictionary <string, string> extraHeaders = null)
{
if (key.StartsWith("/"))
{
throw new ArgumentException($"{nameof(key)} can not start with '/'");
}
var cmd = new PutObjectCommand(_requestContext, bucket, key, file, extraHeaders);
var result = await cmd.ExecuteAsync(_client);
if (!result.IsSuccess)
{
_logger.LogError($"Failed in OssClient.{nameof(PutObjectAsync)}(). \nBucket: {bucket.BucketName}\nPath: {key}");
}
return(result);
}
/// <summary>
/// 获取文件的下载链接
/// </summary>
/// <param name="bucket">bucket信息</param>
/// <param name="storeKey">文件存储key</param>
/// <param name="expireSeconds">签名超时时间秒数</param>
/// <param name="imgStyle">阿里云图片处理样式</param>
/// <returns></returns>
public string GetFileDownloadLink(BucketInfo bucket, string storeKey, int expireSeconds, string imgStyle = null)
{
long seconds = (DateTime.UtcNow.AddSeconds(expireSeconds).Ticks - 621355968000000000) / 10000000;
string toSign = String.Format("GET\n\n\n{0}\n/{1}/{2}", seconds, bucket.BucketName, storeKey);
if (!String.IsNullOrEmpty(imgStyle))
{
toSign += $"?x-oss-process=style/{imgStyle}";
}
string sign = ServiceSignature.Create().ComputeSignature(
_requestContext.OssCredential.AccessKeySecret, toSign);
string styleSegment = String.IsNullOrEmpty(imgStyle) ? String.Empty : $"x-oss-process=style/{imgStyle}&";
string url = $"{bucket.BucketUri}{storeKey}?{styleSegment}OSSAccessKeyId={_requestContext.OssCredential.AccessKeyId}&Expires={seconds}&Signature={WebUtility.UrlEncode(sign)}";
return(url);
}
public void GetBucketInfoTest()
{
var bucketName = OssTestUtils.GetBucketName(_className);
try
{
//assert bucket does not exist
Assert.IsFalse(OssTestUtils.BucketExists(_ossClient, bucketName),
string.Format("Bucket {0} should not exist before creation", bucketName));
//create a new bucket
_ossClient.CreateBucket(bucketName, StorageClass.IA);
OssTestUtils.WaitForCacheExpire();
BucketInfo bucketInfo = _ossClient.GetBucketInfo(bucketName);
Assert.AreEqual(bucketInfo.Bucket.AccessControlList.Grant, CannedAccessControlList.Private);
_ossClient.SetBucketAcl(bucketName, CannedAccessControlList.PublicRead);
OssTestUtils.WaitForCacheExpire();
bucketInfo = _ossClient.GetBucketInfo(bucketName);
Assert.AreEqual(bucketInfo.Bucket.AccessControlList.Grant, CannedAccessControlList.PublicRead);
_ossClient.SetBucketAcl(bucketName, CannedAccessControlList.PublicReadWrite);
OssTestUtils.WaitForCacheExpire();
bucketInfo = _ossClient.GetBucketInfo(bucketName);
Assert.AreEqual(bucketInfo.Bucket.AccessControlList.Grant, CannedAccessControlList.PublicReadWrite);
Assert.IsNotNull(bucketInfo.Bucket.Location);
Assert.IsNotNull(bucketInfo.Bucket.ExtranetEndpoint);
Assert.IsNotNull(bucketInfo.Bucket.IntranetEndpoint);
Assert.AreEqual(bucketInfo.Bucket.StorageClass, StorageClass.IA);
Assert.AreEqual(bucketInfo.Bucket.Name, bucketName);
Assert.IsTrue(bucketInfo.Bucket.ToString().Contains(bucketName));
}
finally
{
_ossClient.DeleteBucket(bucketName);
}
}
public BVH(Bounds[] bounds, Matrix4x4[] transformPositions, ref List <RayTracingSubscriber> subs)
{
/*
* TODO: 1) Create the primInfo for each mesh 2) create the Tree with pointer and SAH 3) Linearize
*/
this.subs = subs;
primitivesInfo = new List <PrimitiveInfo>(transformPositions.Length);
for (int i = 0; i < transformPositions.Length; i++)
{
PrimitiveInfo info = new PrimitiveInfo()
{
bounds = bounds[i],
primitiveIndex = i
};
primitivesInfo.Add(info);
}
for (int i = 0; i < nBuckets; i++)
{
buckets[i] = new BucketInfo();
}
List <RayTracingSubscriber> orderedInfos = new List <RayTracingSubscriber>(primitivesInfo.Count);
root = RecursiveBuild(0, primitivesInfo.Count, ref orderedInfos);
// primitivesInfo = orderedInfos;
subs.Clear();
subs.AddRange(orderedInfos);
flatTree = new LBVH[nodeCreated];
int offset = 0;
FlattenTree(root, ref offset);
}
internal void SetProperties()
{
if (_propertiesSet) return;
// first make sure your set to your input's properties
foreach (InternalRecordSource source in _inputList) {
source.SetProperties();
if (_passThruInputSorting) _sorting = source.Sorting;
if (_passThruInputBucketting) _bucketting = source.Bucketting;
if (_passThruInputSegmenting) _segmenting = source.Segmenting;
if (_passThruInputReduced) _isReduced = source.IsReduced;
}
_propertiesSet = true;
}
/// <summary>
/// 上传文件
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="file"></param>
/// <returns></returns>
public async Task <OssResult <PutObjectResult> > PutObjectAsync(BucketInfo bucket, string key, RequestContent file)
{
var cmd = new PutObjectCommand(_requestContext, bucket, key, file, null);
return(await cmd.ExecuteAsync());
}
/// <summary>
/// Get Object Meta用来获取某个Bucket下的某个Object的基本meta信息，包括该Object的ETag、Size（文件大小）、LastModified，并不返回其内容。
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <returns></returns>
public async Task <OssResult <GetObjectMetaResult> > GetObjectMetaAsync(BucketInfo bucket, string key)
{
var cmd = new GetObjectMetaCommand(_requestContext, bucket, key);
return(await cmd.ExecuteAsync());
}
/// <summary>
/// ead Object只返回某个Object的meta信息，不返回文件内容。
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public async Task <OssResult <HeadObjectResult> > HeadObjectAsync(BucketInfo bucket, string key, HeadObjectParams parameters)
{
var cmd = new HeadObjectCommand(_requestContext, bucket, key, parameters);
return(await cmd.ExecuteAsync());
}
/// <summary>
/// 删除多个对象
/// </summary>
/// <param name="bucket"></param>
/// <param name="keys"></param>
/// <param name="quiet"></param>
/// <returns></returns>
public async Task <OssResult <DeleteMultipleObjectsResult> > DeleteMultipleObjectsAsync(BucketInfo bucket,
IList <string> keys, bool quiet = false)
{
var cmd = new DeleteMultipleObjectsCommand(_requestContext, bucket, keys, quiet);
return(await cmd.ExecuteAsync());
}
