public async Task <bool> DeleteFileAsync(MethodOptions methodOptions, StorageOptions storageOptions, string filePath) { EndpointOptions endpoint = FindWriteEndpoint(methodOptions, storageOptions); if (!endpoint.Provider.IsFullPath) { filePath = Path.Combine(endpoint.Path ?? "", filePath); string fileName = Path.GetFileName(filePath); Log.Information("Command: Remove file {file}", filePath); IBlobStorage storage = _storageProvider.GetStorage(endpoint.Provider, filePath.Replace(fileName, "")); bool fileExist = await storage.ExistsAsync(fileName); if (!fileExist) { return(false); } await storage.DeleteAsync(fileName); } else { IBlobStorage storage = _storageProvider.GetStorage(endpoint.Provider); Log.Information("Command: Remove file {file}", filePath); bool fileExist = await storage.ExistsAsync(filePath); if (!fileExist) { return(false); } await storage.DeleteAsync(filePath); } return(true); }
public ClassComposer AddMethod(MethodOptions options) { if (!IsAtRoot()) { throw new Exception("A class must be selected (which is also a root to the composer) to add a method to it."); } TypeSyntax returnType = SyntaxFactory.ParseTypeName(options.ReturnType); var method = SyntaxFactory.MethodDeclaration(returnType, options.MethodName).WithModifiers(options.ModifiersToTokenList()); var @params = SyntaxFactory.ParameterList(); foreach (var param in options.Parameters) { var type = SyntaxFactory.IdentifierName(param.Type); var name = SyntaxFactory.Identifier(param.Name); var paramSyntax = SyntaxFactory .Parameter(new SyntaxList <AttributeListSyntax>(), SyntaxFactory.TokenList(), type, name, null); @params = @params.AddParameters(paramSyntax); } @params = @params.NormalizeWhitespace(); method = method.WithParameterList(@params); method = method.WithBody(SyntaxFactory.Block()); var newNode = (CurrentNode as ClassDeclarationSyntax).AddMembers(method); Replace(CurrentNode, newNode, null); return(this); }
public async Task <Stream> DownloadFileAsync(MethodOptions methodOptions, StorageOptions storageOptions, string filePath) { EndpointOptions endpoint = FindReadEndpoint(methodOptions, storageOptions); if (!endpoint.Provider.IsFullPath) { filePath = Path.Combine(endpoint.Path ?? "", filePath); Log.Information("Query: Download file {file}", filePath); string fileName = Path.GetFileName(filePath); IBlobStorage storage = _storageProvider.GetStorage(endpoint.Provider, filePath.Replace(fileName, "")); bool fileExist = await storage.ExistsAsync(fileName); if (!fileExist) { return(null); } return(await storage.OpenReadAsync(fileName)); } else { Log.Information("Query: Download file {file}", filePath); IBlobStorage storage = _storageProvider.GetStorage(endpoint.Provider); bool fileExist = await storage.ExistsAsync(filePath); if (!fileExist) { return(null); } return(await storage.OpenReadAsync(filePath)); } }
public async Task AddFileAsync(MethodOptions methodOptions, StorageOptions storageOptions, IFormFileCollection files, string subPath) { ICollection <EndpointOptions> endpoints = GetWriteEndpoints(methodOptions, storageOptions).ToList(); foreach (var file in files) { if (string.IsNullOrEmpty(file.FileName)) { Log.Warning("Attempt to upload a file with a null or empty name"); continue; } try { foreach (EndpointOptions endpoint in endpoints) { IBlobStorage storage = _storageProvider.GetStorage(endpoint.Provider); using (var fs = file.OpenReadStream()) { await storage.WriteAsync(file.FileName, fs); } } } catch (Exception ex) { Log.Error(ex, ex.Message); } } }
internal HttpContextServerCallContext(HttpContext httpContext, MethodOptions options, Type requestType, Type responseType, ILogger logger) { HttpContext = httpContext; Options = options; RequestType = requestType; ResponseType = responseType; Logger = logger; }
public JsonTranscodingServerCallContext(HttpContext httpContext, MethodOptions options, IMethod method, CallHandlerDescriptorInfo descriptorInfo, ILogger logger) { HttpContext = httpContext; Options = options; _method = method; DescriptorInfo = descriptorInfo; Logger = logger; }
/// <summary> /// Creates a new instance of <see cref="ServerMethodInvokerBase{TService, TRequest, TResponse}"/>. /// </summary> /// <param name="method">The description of the gRPC method.</param> /// <param name="options">The options used to execute the method.</param> /// <param name="serviceActivator">The service activator used to create service instances.</param> private protected ServerMethodInvokerBase( Method <TRequest, TResponse> method, MethodOptions options, IGrpcServiceActivator <TService> serviceActivator) { Method = method; Options = options; ServiceActivator = serviceActivator; }
public Data(int health, string name, int age, MethodOptions method = MethodOptions.POST, ErrorOptions error = ErrorOptions.ERROR_NONE, ResponseOptions response = ResponseOptions.OK) { this.Health = health; this.Name = name; this.Method = method; this.Age = age; this.Error = error; this.Response = response; this.List = new[] { "", "" }; }
public async Task <ICollection <FileMetadatas> > ListFilesAsync(MethodOptions methodOptions, StorageOptions storageOptions, ListOptions listOptions = null) { ICollection <EndpointOptions> endpoints = GetReadEndpoints(methodOptions, storageOptions).ToList(); _logger.LogInformation("List files in directories {@directory}", endpoints.Select(e => e.Path)); IEnumerable <IBlobStorage> storages = endpoints.Select(e => _storageProvider.GetStorage(e.Provider)); IEnumerable <Task <IReadOnlyCollection <BlobId> > > readTasks = storages.Select(x => x.ListAsync(listOptions)); IEnumerable <BlobId> blobs = (await Task.WhenAll(readTasks)).SelectMany(x => x.Select(t => t)); _logger.LogDebug("Listed files {@blobs}", blobs); return(blobs.Select(x => x.ToFileMetadata()).ToList()); }
public HttpApiServerCallContext(HttpContext httpContext, MethodOptions options, IMethod method, CallHandlerDescriptorInfo descriptorInfo, ILogger logger) { HttpContext = httpContext; Options = options; _method = method; DescriptorInfo = descriptorInfo; Logger = logger; IsJsonRequestContent = JsonRequestHelpers.HasJsonContentType(httpContext.Request, out var charset); RequestEncoding = JsonRequestHelpers.GetEncodingFromCharset(charset) ?? Encoding.UTF8; // Add the HttpContext to UserState so GetHttpContext() continues to work HttpContext.Items["__HttpContext"] = httpContext; }
/// <summary> /// Creates a new instance of <see cref="DuplexStreamingServerMethodInvoker{TService, TRequest, TResponse}"/>. /// </summary> /// <param name="invoker">The duplex streaming method to invoke.</param> /// <param name="method">The description of the gRPC method.</param> /// <param name="options">The options used to execute the method.</param> /// <param name="serviceActivator">The service activator used to create service instances.</param> public DuplexStreamingServerMethodInvoker( DuplexStreamingServerMethod <TService, TRequest, TResponse> invoker, Method <TRequest, TResponse> method, MethodOptions options, IGrpcServiceActivator <TService> serviceActivator) : base(method, options, serviceActivator) { _invoker = invoker; if (Options.HasInterceptors) { var interceptorPipeline = new InterceptorPipelineBuilder <TRequest, TResponse>(Options.Interceptors); _pipelineInvoker = interceptorPipeline.DuplexStreamingPipeline(ResolvedInterceptorInvoker); } }
private IEnumerable <EndpointOptions> GetWriteEndpoints(MethodOptions methodOptions, StorageOptions storageOptions) { IEnumerable <EndpointOptions> endpoints; if (methodOptions?.WriteEndpoints != null && storageOptions?.WriteEndpoints != null) { endpoints = methodOptions?.WriteEndpoints ?? storageOptions?.WriteEndpoints; } else { endpoints = new List <EndpointOptions> { methodOptions?.WriteEndpoint ?? methodOptions?.Endpoint ?? storageOptions?.WriteEndpoint ?? storageOptions?.Endpoint }; } return(endpoints); }
public async Task <ICollection <FileMetadatas> > SearchFilesAsync(MethodOptions methodOptions, StorageOptions storageOptions, string fileName) { string pattern = string.IsNullOrEmpty(methodOptions.Pattern) ? fileName : methodOptions.Pattern.Replace("{fileName}", fileName); ICollection <EndpointOptions> endpoints = GetReadEndpoints(methodOptions, storageOptions).ToList(); _logger.LogInformation("Query: Search files in directory {@directory} with pattern {pattern}", endpoints.Select(e => e.Path), pattern); IDictionary <EndpointOptions, IBlobStorage> storages = endpoints.ToDictionary(e => e, e => _storageProvider.GetStorage(e.Provider)); List <FileMetadatas> filesMetadatas = new List <FileMetadatas>(); List <Task <IReadOnlyCollection <BlobId> > > storageTasks = new List <Task <IReadOnlyCollection <BlobId> > >(); foreach (KeyValuePair <EndpointOptions, IBlobStorage> storage in storages) { if (storage.Key.Provider.StorageType == StorageType.Directory && storage.Key.IsRegex) { IEnumerable <string> searchFiles = Directory.EnumerateFiles(storage.Key.Provider.Directory, pattern, SearchOption.AllDirectories); foreach (string file in searchFiles) { string name = Path.GetFileName(file); string nameWithoutExt = name.Remove(name.LastIndexOf(".", StringComparison.InvariantCultureIgnoreCase)); string parent = Path.GetFileName(Path.GetDirectoryName(file)); filesMetadatas.Add(new FileMetadatas { FullPath = file, Name = name, Parent = parent, NameWithoutExt = nameWithoutExt }); } } else { storageTasks.Add(storage.Value.ListAsync(new ListOptions { Recurse = true })); } } var taskResults = await Task.WhenAll(storageTasks); foreach (var taskResult in taskResults) { filesMetadatas.AddRange(taskResult.Select(x => x.ToFileMetadata())); } return(filesMetadatas); }
Dictionary <string, string> DumpOptions(FileDescriptorProto source, MethodOptions options) { var optionsKv = new Dictionary <string, string>(); if (options == null) { return(optionsKv); } if (options.deprecatedSpecified) { optionsKv.Add("deprecated", options.deprecated ? "true" : "false"); } DumpOptionsMatching(source, ".google.protobuf.MethodOptions", options, optionsKv); return(optionsKv); }
public static MethodOptions CreateMethodOptions( List <ICompressionProvider>?compressionProviders = null, string?responseCompressionAlgorithm = null, CompressionLevel?responseCompressionLevel = null, int?maxSendMessageSize = null, int?maxReceiveMessageSize = null, InterceptorCollection?interceptors = null) { var serviceOptions = new GrpcServiceOptions(); serviceOptions.CompressionProviders = compressionProviders ?? new List <ICompressionProvider>(); serviceOptions.Interceptors.AddRange(interceptors ?? new InterceptorCollection()); serviceOptions.MaxSendMessageSize = maxSendMessageSize; serviceOptions.MaxReceiveMessageSize = maxReceiveMessageSize; serviceOptions.ResponseCompressionAlgorithm = responseCompressionAlgorithm; serviceOptions.ResponseCompressionLevel = responseCompressionLevel; return(MethodOptions.Create(new[] { serviceOptions })); }
/// <summary> /// Get all of the fields of an object /// </summary> /// <param name="type"></param> /// <param name="options">True to include the compiler generated backing fields for auto-property getters/setters</param> /// <returns></returns> public static ICollection <ExtendedMethod> GetMethods(this Type type, MethodOptions options) { if (type == null) { return(new List <ExtendedMethod>()); } var flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static; var allMethods = type.GetMethods(flags) .Select(x => new ExtendedMethod(x, type)) .Concat(GetMethods(type.BaseType, options)); IEnumerable <ExtendedMethod> returnMethods = allMethods; if (options.HasFlag(MethodOptions.Public)) { returnMethods = returnMethods.Where(x => x.IsPublic); } if (options.HasFlag(MethodOptions.Private)) { returnMethods = returnMethods.Where(x => x.IsPrivate); } if (options.HasFlag(MethodOptions.Static)) { returnMethods = returnMethods.Where(x => x.IsStatic); } if (options.HasFlag(MethodOptions.Overridden)) { returnMethods = allMethods.Where(x => x.IsOverride); } if (options.HasFlag(MethodOptions.Virtual)) { returnMethods = returnMethods.Where(x => x.IsVirtual); } if (options.HasFlag(MethodOptions.Constructor)) { returnMethods = returnMethods.Where(x => x.IsConstructor); } return(returnMethods.Select(x => (ExtendedMethod)x).ToList()); }
/// <summary>Serialize the instance into the stream</summary> public static void Serialize(Stream stream, MethodOptions instance) { if (instance.UninterpretedOption != null) { foreach (var i999 in instance.UninterpretedOption) { // Key for field: 999, LengthDelimited stream.Write(new byte[]{186, 62}, 0, 2); using (var ms999 = new MemoryStream()) { Google.protobuf.UninterpretedOption.Serialize(ms999, i999); // Length delimited byte array uint ms999Length = (uint)ms999.Length; global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms999Length); stream.Write(ms999.GetBuffer(), 0, (int)ms999Length); } } } }
/// <summary>Helper: Serialize with a varint length prefix</summary> public static void SerializeLengthDelimited(Stream stream, MethodOptions instance) { var data = SerializeToBytes(instance); global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, (uint)data.Length); stream.Write(data, 0, data.Length); }
/// <summary>Helper: create a new instance to deserializing into</summary> public static MethodOptions DeserializeLength(Stream stream, int length) { MethodOptions instance = new MethodOptions(); DeserializeLength(stream, length, instance); return instance; }
/// <summary>Helper: create a new instance to deserializing into</summary> public static MethodOptions DeserializeLengthDelimited(Stream stream) { MethodOptions instance = new MethodOptions(); DeserializeLengthDelimited(stream, instance); return instance; }
/// <summary>Helper: create a new instance to deserializing into</summary> public static MethodOptions Deserialize(Stream stream) { MethodOptions instance = new MethodOptions(); Deserialize(stream, instance); return instance; }
/// <summary>Helper: put the buffer into a MemoryStream and create a new instance to deserializing into</summary> public static MethodOptions Deserialize(byte[] buffer) { MethodOptions instance = new MethodOptions(); using (var ms = new MemoryStream(buffer)) Deserialize(ms, instance); return instance; }
/// <summary>Serialize the instance into the stream</summary> public static void Serialize(Stream stream, MethodOptions instance) { var msField = global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Pop(); if (instance.UninterpretedOption != null) { foreach (var i999 in instance.UninterpretedOption) { // Key for field: 999, LengthDelimited stream.WriteByte(186); stream.WriteByte(62); msField.SetLength(0); Google.Protobuf.UninterpretedOption.Serialize(msField, i999); // Length delimited byte array uint length999 = (uint)msField.Length; global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length999); msField.WriteTo(stream); } } global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Push(msField); }
private MethodOptions CreateMethodOptions() { return(MethodOptions.Create(new[] { _globalOptions, _serviceOptions })); }
/// <summary>Helper: Serialize into a MemoryStream and return its byte array</summary> public static byte[] SerializeToBytes(MethodOptions instance) { using (var ms = new MemoryStream()) { Serialize(ms, instance); return ms.ToArray(); } }
/// <summary> /// 缓存代理 /// </summary> /// <typeparam name="T">返回类型</typeparam> /// <param name="key">关键字</param> /// <param name="suffix">关键字后接字符串(可为空)</param> /// <param name="expiry">过期时间(绝对)</param> /// <param name="acquire">方法变量</param> /// <param name="methodOptions">操作类型</param> /// <returns>缓存数据</returns> /// <remarks>2013-08-01 黄波 创建</remarks> private static T BaseGet <T>(string key, string suffix, DateTime expiry, Func <T> acquire, MethodOptions methodOptions) { var returnValue = default(T); //如果缓存关闭则不执行缓存策略 if (CacheState != _CacheState.Open.ToString()) { if (acquire == null) { return(returnValue); } return(acquire()); } //缓存关键字 var cacheKey = key.ToString(); if (!string.IsNullOrEmpty(suffix)) { cacheKey += suffix; } //缓存键是否存在 var cacheExists = CacheManager.Instance.IsExists(cacheKey); //强制重新缓存 //或者缓存不存在时重新缓存 if (methodOptions == MethodOptions.ForcedUpdating || !cacheExists) { //存在则更新 否则设置 if (acquire != null) { returnValue = acquire(); if (cacheExists) { CacheManager.Instance.Update(cacheKey, returnValue, expiry); } else { CacheManager.Instance.Set(cacheKey, returnValue, expiry); } return(returnValue); } } object o = CacheManager.Instance.Get <object>(cacheKey); return(CacheManager.Instance.Get <T>(cacheKey)); }
/// <summary> /// 缓存代理 /// </summary> /// <typeparam name="T">返回类型</typeparam> /// <param name="key">枚举类型关键字</param> /// <param name="acquire">方法变量</param> /// <param name="methodOptions">操作类型</param> /// <returns>缓存数据</returns> /// <remarks>2013-08-01 黄波 创建</remarks> public static T Get <T>(CacheKeys.Items key, Func <T> acquire, MethodOptions methodOptions = MethodOptions.Get) { return(BaseGet <T>(key.ToString(), null, DateTime.Now.AddMinutes(CacheExpiry), acquire, methodOptions)); }
/// <summary> /// 缓存代理 /// </summary> /// <typeparam name="T">返回类型</typeparam> /// <param name="key">枚举类型关键字</param> /// <param name="acquire">方法变量</param> /// <param name="expiry">过期时间</param> /// <param name="methodOptions">操作类型</param> /// <returns>缓存数据</returns> /// <remarks>2013-08-01 黄波 创建</remarks> public static T Get <T>(CacheKeys.Items key, DateTime expiry, Func <T> acquire, MethodOptions methodOptions = MethodOptions.Get) { return(BaseGet <T>(key.ToString(), null, expiry, acquire, methodOptions)); }
private EndpointOptions FindWriteEndpoint(MethodOptions methodOptions, StorageOptions storageOptions) { return(methodOptions?.WriteEndpoint ?? methodOptions?.Endpoint ?? storageOptions?.WriteEndpoint ?? storageOptions?.Endpoint); }
/// <summary> /// 缓存代理 /// </summary> /// <typeparam name="T">返回类型</typeparam> /// <param name="prefixKey">前缀关键字</param> /// <param name="suffix">关键字后接字符串</param> /// <param name="expiry">过期时间</param> /// <param name="acquire">方法变量</param> /// <param name="methodOptions">操作类型</param> /// <returns>缓存数据</returns> /// <remarks>2013-08-01 黄波 创建</remarks> public static T Get <T>(CacheKeys.Items prefixKey, string suffix, DateTime expiry, Func <T> acquire, MethodOptions methodOptions = MethodOptions.Get) { return(BaseGet <T>(prefixKey.ToString(), suffix, expiry, acquire, methodOptions)); }
/// <summary> /// 缓存代理 /// </summary> /// <typeparam name="T">返回类型</typeparam> /// <param name="prefixKey">前缀关键字</param> /// <param name="suffix">关键字后接字符串</param> /// <param name="expiry">过期时间</param> /// <param name="acquire">方法变量</param> /// <param name="methodOptions">操作类型</param> /// <returns>缓存数据</returns> /// <remarks>2013-08-01 黄波 创建</remarks> public static T Get <T>(string prefixKey, string suffix, DateTime expiry, Func <T> acquire, MethodOptions methodOptions = MethodOptions.Get) { return(BaseGet <T>(prefixKey, suffix, expiry, acquire, methodOptions)); }
/// <summary> /// Get all of the methods of an object /// </summary> /// <param name="obj"></param> /// <param name="options"></param> /// <returns></returns> public static ICollection <ExtendedMethod> GetMethods(this object obj, MethodOptions options) { return(obj.GetType().GetMethods(options)); }
/// <summary> /// 缓存代理 /// </summary> /// <typeparam name="T">返回类型</typeparam> /// <param name="prefixKey">前缀关键字</param> /// <param name="suffix">关键字后接字符串</param> /// <param name="expiry">过期时间</param> /// <param name="acquire">方法变量</param> /// <param name="methodOptions">操作类型</param> /// <returns>缓存数据</returns> /// <remarks>2013-08-01 黄波 创建</remarks> public static T Get <T>(string prefixKey, Func <T> acquire, MethodOptions methodOptions = MethodOptions.Get) { return(BaseGet <T>(prefixKey, "", DateTime.Now.AddMinutes(CacheExpiry), acquire, methodOptions)); }