internal static extern int select( [In] int ignoredParameter, [In, Out] ref FileDescriptorSet readfds, [In, Out] ref FileDescriptorSet writefds, [In, Out] ref FileDescriptorSet exceptfds, [In] IntPtr nullTimeout );
public void DescriptorProtoVB() { var schemaPath = Path.Combine(Directory.GetCurrentDirectory(), SchemaPath); var path = "descriptor.proto"; var set = new FileDescriptorSet(); set.AddImportPath(schemaPath); set.Add(path, includeInOutput: true); set.Process(); #pragma warning disable CS0618 var sourceFiles = VBCodeGenerator.Default.Generate(set).Select(x => x.Text).ToArray(); #pragma warning restore CS0618 Assert.Single(sourceFiles); _output.WriteLine(sourceFiles[0]); var vb = new VBCodeProvider(new Dictionary <string, string> { { "CompilerVersion", "v3.5" } }); var p = new CompilerParameters { GenerateInMemory = true }; p.ReferencedAssemblies.Add(typeof(ProtoContractAttribute).Assembly.Location); // add protobuf-net reference p.ReferencedAssemblies.Add("System.dll"); // for [DefaultValue] p.ReferencedAssemblies.Add("System.Core.dll"); // for extension methods var results = vb.CompileAssemblyFromSource(p, sourceFiles); Assert.Empty(results.Errors); }
public void LargeDefaultValueIsCorrect() { var schemaPath = Path.Combine(Directory.GetCurrentDirectory(), SchemaPath); const string path = "bigIntegerDefaultValue.proto"; var set = new FileDescriptorSet(); set.AddImportPath(schemaPath); set.Add(path, includeInOutput: true); set.Process(); var langver = set.Files[0].Options.GetOptions()?.CSharpLanguageVersion; Assert.Equal("3", langver); var sourceFiles = CSharpCodeGenerator.Default.Generate(set).Select(x => x.Text).ToArray(); Assert.Single(sourceFiles); _output.WriteLine(sourceFiles[0]); var csharp = new CSharpCodeProvider(new Dictionary <string, string> { { "CompilerVersion", "v3.5" } }); var p = new CompilerParameters { GenerateInMemory = true }; p.ReferencedAssemblies.Add(typeof(ProtoContractAttribute).Assembly.Location); // add protobuf-net reference p.ReferencedAssemblies.Add("System.dll"); // for [DefaultValue] p.ReferencedAssemblies.Add("System.Core.dll"); // for extension methods CompilerResults results; try { results = csharp.CompileAssemblyFromSource(p, sourceFiles); Assert.Empty(results.Errors); } catch (PlatformNotSupportedException) { return; } var assembly = results.CompiledAssembly; var messageType = assembly.GetType("TestMessage"); var properties = messageType.GetProperties(); Assert.Equal(2, properties.Length); foreach (var property in properties) { var defaultValueAttribute = (DefaultValueAttribute)Attribute.GetCustomAttribute(property, typeof(DefaultValueAttribute)); Assert.NotNull(defaultValueAttribute); Assert.Equal(18446744073709551615UL, defaultValueAttribute.Value); } }
public static IEnumerable <ResultFile> Generate(FileDescriptorSet descriptorSet, string package, IClock clock, string grpcServiceConfigPath, IEnumerable <string> commonResourcesConfigPaths, bool generateMetadata) { var descriptors = descriptorSet.File; var filesToGenerate = descriptors.Where(x => x.Package == package).Select(x => x.Name).ToList(); return(Generate(descriptors, filesToGenerate, clock, grpcServiceConfigPath, commonResourcesConfigPaths, generateMetadata)); }
public void TestProtoInput() { FileDescriptorSet files = new FileDescriptorSet(); Assert.Equal(0, files.file.Count); InputFileLoader.Merge(files, @"ProtoGen\descriptor.proto", Console.Error); Assert.Equal(1, files.file.Count); }
public byte[] GetFileDescriptorSet() { var descriptor = Descriptors.Last(); var output = new FileDescriptorSet(); output.File.AddRange(GetSelfAndDependency(descriptor.File).Select(x => x.SerializedData)); return(output.ToByteArray()); }
private void Test() { using (var stream = File.OpenRead(@"C:\Users\Agando\Desktop\protoc-3.9.1-win64\bin\grpcserverschema")) { FileDescriptorSet descriptorSet = FileDescriptorSet.Parser.ParseFrom(stream); Google.Protobuf.Collections.RepeatedField <FileDescriptorProto> descriptorsProto = descriptorSet.File; } }
private void GenCSLuaTable() { FileDescriptorSet lset = m_reader.GetExcludeLuaProtoFileSet(); using (var converter = new ProtoConverter(m_strOutputPath, "")) { converter.Convert(lset); } }
/// <summary> /// Creates a new <see cref="ReflectionService"/> instance /// </summary> public ReflectionService( FileDescriptorSet fileDescriptorSet) { _services = fileDescriptorSet.Files .SelectMany(x => x.Services) .Select(x => x.FullyQualifiedName.TrimStart('.')) .ToList(); _symbolRegistry = SymbolRegistry.FromFiles(fileDescriptorSet); }
public override IEnumerable <CodeFile> Generate(FileDescriptorSet set, NameNormalizer normalizer = null, Dictionary <string, string> options = null) { if (normalizer == null) { normalizer = NameNormalizer.Null; } return(base.Generate(set, normalizer, options)); }
internal static int Main(string[] args) { try { // Hack to make sure everything's initialized DescriptorProtoFile.Descriptor.ToString(); GeneratorOptions options = new GeneratorOptions { Arguments = args }; IList <string> validationFailures; if (!options.TryValidate(out validationFailures)) { // We've already got the message-building logic in the exception... InvalidOptionsException exception = new InvalidOptionsException(validationFailures); Console.WriteLine(exception.Message); return(1); } var request = new CodeGeneratorRequest.Builder(); foreach (string inputFile in options.InputFiles) { ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance(); CSharpOptions.RegisterAllExtensions(extensionRegistry); using (Stream inputStream = File.OpenRead(inputFile)) { var fileSet = FileDescriptorSet.ParseFrom(inputStream, extensionRegistry); foreach (var fileProto in fileSet.FileList) { request.AddFileToGenerate(fileProto.Name); request.AddProtoFile(fileProto); } } } Generator generator = Generator.CreateGenerator(options); var response = new CodeGeneratorResponse.Builder(); generator.Generate(request.Build(), response); if (response.HasError) { throw new Exception(response.Error); } foreach (var file in response.FileList) { File.WriteAllText(file.Name, file.Content); } return(0); } catch (Exception e) { Console.Error.WriteLine("Error: {0}", e.Message); Console.Error.WriteLine(); Console.Error.WriteLine("Detailed exception information: {0}", e); return(1); } }
public static FileDescriptorSet LoadFilesAsFileDescription(params string[] files) { FileDescriptorSet set = new FileDescriptorSet(); foreach (string inPath in files) { InputFileLoader.Merge(set, inPath, Console.Error); } return(set); }
private IReadOnlyCollection <FileDescriptor> ReadCompiledProtobufModel2(string pathToCompileProtobufModel) { using (var stream = File.OpenRead(pathToCompileProtobufModel)) { FileDescriptorSet descriptorSet = FileDescriptorSet.Parser.ParseFrom(stream); var byteStrings = descriptorSet.File.Select(f => f.ToByteString()).ToList(); var descriptors = FileDescriptor.BuildFromByteStrings(byteStrings); return(descriptors); } }
/// <summary> /// Creates a symbol registry from the specified set of file descriptors. /// </summary> /// <param name="fileDescriptorSet">The set of files to include in the registry. Must not contain null values.</param> /// <returns>A symbol registry for the given files.</returns> public static SymbolRegistry FromFiles(FileDescriptorSet fileDescriptorSet) { GrpcPreconditions.CheckNotNull(fileDescriptorSet); var builder = new Builder(); foreach (var file in fileDescriptorSet.Files) { builder.AddFile(file); } return(builder.Build()); }
public GenerateResult Generate(string schema = null, string tooling = null) { if (string.IsNullOrWhiteSpace(schema)) { return(null); } var result = new GenerateResult(); try { using (var reader = new StringReader(schema)) { var set = new FileDescriptorSet { ImportValidator = path => ValidateImport(path), }; set.AddImportPath(Path.Combine(_host.WebRootPath, "protoc")); set.Add("my.proto", true, reader); set.Process(); var errors = set.GetErrors(); if (!ProtocTooling.IsDefined(tooling)) { if (errors.Length > 0) { result.ParserExceptions = errors; } result.Files = CSharpCodeGenerator.Default.Generate(set).ToArray(); } else { // we're going to offer protoc! hold me... if (errors.Length != 0 && schema.Contains("import")) { // code output disabled because of import } else { result.Files = RunProtoc(_host, schema, tooling, out errors); if (errors.Length > 0) { result.ParserExceptions = errors; } } } } } catch (Exception ex) { result.Exception = ex; } return(result); }
public void SelfDependency() { FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "First" } }.Build(); FileDescriptorSet set = new FileDescriptorSet { FileList = { first } }; try { Generator.ConvertDescriptors(set); Assert.Fail("Expected exception"); } catch (DependencyResolutionException) { // Expected } }
private IReadOnlyCollection <FileDescriptorProto> ReadCompiledProtobufModel(string pathToCompileProtobufModel) { using (var stream = File.OpenRead(pathToCompileProtobufModel)) { FileDescriptorSet descriptorSet = FileDescriptorSet.Parser.ParseFrom(stream); RepeatedField <FileDescriptorProto> descriptorsProto = descriptorSet.File; var result = new FileDescriptorProto[descriptorsProto.Capacity]; descriptorsProto.CopyTo(result, 0); return(result); } }
public void Convert(FileDescriptorSet lset) { if (m_isworking) { return; } m_isworking = true; FilterClass(GotIt, lset); m_isworking = false; }
private static FileDescriptorSet GetSet(IEnumerable <DirectoryInfo> importPaths) { var set = new FileDescriptorSet(); foreach (var path in importPaths) { set.AddImportPath(path.FullName); } return(set); }
public bool Register(Stream source) { lastError.Clear(); FileDescriptorSet desc = new FileDescriptorSet(); Serializer.Merge <FileDescriptorSet>(source, desc); buildFileDescriptor(desc); return(lastError.Count == 0); }
public void SecondDependsOnFirst() { FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First" }.Build(); FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = {"First"} }.Build(); FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } }; IList<FileDescriptor> converted = Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set); Assert.AreEqual(2, converted.Count); Assert.AreEqual("First", converted[0].Name); Assert.AreEqual(0, converted[0].Dependencies.Count); Assert.AreEqual("Second", converted[1].Name); Assert.AreEqual(1, converted[1].Dependencies.Count); Assert.AreEqual(converted[0], converted[1].Dependencies[0]); }
private void buildFileDescriptor(FileDescriptorSet desc) { if (desc == null) { throw new ArgumentNullException("FileDescriptorSet can not be null"); } foreach (var fd in desc.file) { if (descriptors.FileDescriptors.ContainsKey(fd.name)) { continue; } descriptors.FileDescriptors.Add(fd.name, fd); foreach (var enum_desc in fd.enum_type) { string enum_key = fd.package.Length > 0? string.Format("{0}.{1}", fd.package, enum_desc.name): enum_desc.name; if (descriptors.EnumDescriptors.ContainsKey(enum_key)) { lastError.AddLast(string.Format("enum discriptor {0} already existed")); } else { descriptors.EnumDescriptors.Add(enum_key, enum_desc); foreach (var enum_val in enum_desc.value) { string enum_val_key = string.Format("{0}.{1}", enum_key, enum_val.name); descriptors.EnumValueDescriptors[enum_val_key] = enum_val; } } } foreach (var msg_desc in fd.message_type) { string key = fd.package.Length > 0 ? string.Format("{0}.{1}", fd.package, msg_desc.name): msg_desc.name; if (descriptors.MsgDescriptors.ContainsKey(key)) { lastError.AddLast(string.Format("message discriptor {0} already existed")); } else { DynamicMessage.MsgDiscriptor res = new DynamicMessage.MsgDiscriptor(); res.Package = fd.package; res.Protocol = msg_desc; res.FieldIdIndex = new Dictionary <int, FieldDescriptorProto>(); res.FieldNameIndex = new Dictionary <string, FieldDescriptorProto>(); descriptors.MsgDescriptors.Add(key, res); } } } }
public void TestBinaryInput() { // compile .proto to .bin Process.Start("protoc", @"--descriptor_set_out=ProtoGen\descriptor.bin --include_imports ProtoGen\descriptor.proto").WaitForExit(); // process .bin FileDescriptorSet files = new FileDescriptorSet(); Assert.Equal(0, files.file.Count); InputFileLoader.Merge(files, @"ProtoGen\descriptor.bin", Console.Error); Assert.Equal(1, files.file.Count); }
public static void ParsePB(string FilePath, string outputFilePath) { var pbFile = FileDescriptorSet.ParseFrom(File.ReadAllBytes(FilePath)); var protoList = pbFile.FileList; //指代特定proto foreach (var proto in protoList) { ParseProto(proto, outputFilePath); } }
public void FirstDependsOnSecond() { FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = {"Second"} }.Build(); FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second" }.Build(); FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } }; IList<FileDescriptor> converted = Generator.ConvertDescriptors(set); Assert.AreEqual(2, converted.Count); Assert.AreEqual("First", converted[0].Name); Assert.AreEqual(1, converted[0].Dependencies.Count); Assert.AreEqual(converted[1], converted[0].Dependencies[0]); Assert.AreEqual("Second", converted[1].Name); Assert.AreEqual(0, converted[1].Dependencies.Count); }
public void EmbeddedImportsWork() { var set = new FileDescriptorSet(); using (var file = File.OpenText("basic.proto")) { Assert.True(set.Add("basic.proto", true, file)); } set.Process(); var err = set.GetErrors(); Assert.Empty(err); }
public void Parsed_ShouldReturnParsedSchemaContents() { string contents = SchemaFixtureUtils.GetProtoBuf("ValidSchema"); var schema = new ProtoBufSchema( Guid.NewGuid(), new SchemaGroupAggregate.Schemas.Version(1), contents); FileDescriptorSet descriptor = schema.Parsed; Assert.NotNull(descriptor); Assert.Empty(descriptor.GetErrors()); }
internal static FileDescriptorSet Create(IEnumerable <Type> serviceTypes, BinderConfiguration?binderConfiguration = null) { var fileDescriptorSet = new FileDescriptorSet(); binderConfiguration ??= BinderConfiguration.Default; foreach (var serviceType in serviceTypes) { Populate(fileDescriptorSet, serviceType, binderConfiguration); } fileDescriptorSet.Process(); return(fileDescriptorSet); }
public IActionResult Generate([FromBody] GeneratorViewModel generatorViewModel) { using (var reader = new StringReader(generatorViewModel.ProtoContent)) { var set = new FileDescriptorSet { ImportValidator = path => ValidateImport(path), }; set.AddImportPath(Path.Combine(_host.WebRootPath, "protoc")); set.Add("my.proto", true, reader); set.Process(); var errors = set.GetErrors(); if (errors.Length != 0) { //code parsing is supposed to happening client side, so we don't send error here return(BadRequest()); } if (generatorViewModel.IsProtobugGen()) { return(Ok( generatorViewModel .GetCodeGenerator() .Generate(set, generatorViewModel.GetNameNormalizerForConvention(), generatorViewModel.GetOptions()) .ToList())); } // we're going to offer protoc! hold me... if (generatorViewModel.ProtoContent.Contains("import")) { // code output disabled because of import return(BadRequest()); } else { var files = RunProtoc(_host, generatorViewModel.ProtoContent, generatorViewModel.GetProtocTooling(), out var stdout, out var stderr, out var exitCode); if (exitCode != 0) { return(base.StatusCode(500, new { stderr, stdout, exitCode })); } return(Ok(files)); } } }
private IEnumerable <ResultFile> Run(IEnumerable <string> protoFilenames, string package, string grpcServiceConfigPath, IEnumerable <string> commonResourcesConfigPaths, bool generateMetadata) { var clock = new FakeClock(new DateTime(2019, 1, 1)); var protoPaths = protoFilenames.Select(x => Path.Combine(Invoker.GeneratorTestsDir, x)); using (var desc = Invoker.TempFile()) { Invoker.Protoc($"-o {desc} --experimental_allow_proto3_optional --include_imports --include_source_info " + $"-I{Invoker.CommonProtosDir} -I{Invoker.ProtobufDir} -I{Invoker.GeneratorTestsDir} {string.Join(" ", protoPaths)}"); var descriptorBytes = File.ReadAllBytes(desc.Path); FileDescriptorSet descriptorSet = FileDescriptorSet.Parser.ParseFrom(descriptorBytes); return(CodeGenerator.Generate(descriptorSet, package, clock, grpcServiceConfigPath, commonResourcesConfigPaths, generateMetadata)); } }
static bool IsValidBinary(string path) { try { using (FileStream stream = File.OpenRead(path)) { FileDescriptorSet file = Serializer.Deserialize <FileDescriptorSet>(stream); return(file != null); } } catch { return(false); } }
public void BuildTypeHierarchyForServices() { var set = new FileDescriptorSet(); using (var file = File.OpenText("basic_service.proto")) { Assert.True(set.Add("basic_service.proto", true, file)); } set.Process(); var err = set.GetErrors(); Assert.Empty(err); Assert.Equal(".HelloWorld.HelloService", set.Files[0].Services[0].FullyQualifiedName); Assert.Equal(".HelloWorld.HelloService.SayHello", set.Files[0].Services[0].Methods[0].FullyQualifiedName); }
public void SelfDependency() { FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "First" } }.Build(); FileDescriptorSet set = new FileDescriptorSet { FileList = { first } }; try { Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set); Assert.Fail("Expected exception"); } catch (DependencyResolutionException) { // Expected } }
/// <summary>Helper: create a new instance to deserializing into</summary> public static FileDescriptorSet Deserialize(Stream stream) { FileDescriptorSet instance = new FileDescriptorSet(); Deserialize(stream, instance); return instance; }
/// <summary>Helper: Serialize into a MemoryStream and return its byte array</summary> public static byte[] SerializeToBytes(FileDescriptorSet instance) { using (var ms = new MemoryStream()) { Serialize(ms, instance); return ms.ToArray(); } }
/// <summary>Helper: Serialize with a varint length prefix</summary> public static void SerializeLengthDelimited(Stream stream, FileDescriptorSet instance) { var data = SerializeToBytes(instance); global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, (uint)data.Length); stream.Write(data, 0, data.Length); }
/// <summary>Serialize the instance into the stream</summary> public static void Serialize(Stream stream, FileDescriptorSet instance) { if (instance.File != null) { foreach (var i1 in instance.File) { // Key for field: 1, LengthDelimited stream.WriteByte(10); using (var ms1 = new MemoryStream()) { Google.protobuf.FileDescriptorProto.Serialize(ms1, i1); // Length delimited byte array uint ms1Length = (uint)ms1.Length; global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms1Length); stream.Write(ms1.GetBuffer(), 0, (int)ms1Length); } } } }
/// <summary>Helper: create a new instance to deserializing into</summary> public static FileDescriptorSet DeserializeLengthDelimited(Stream stream) { FileDescriptorSet instance = new FileDescriptorSet(); DeserializeLengthDelimited(stream, instance); return instance; }
/// <summary>Helper: create a new instance to deserializing into</summary> public static FileDescriptorSet DeserializeLength(Stream stream, int length) { FileDescriptorSet instance = new FileDescriptorSet(); DeserializeLength(stream, length, instance); return instance; }
/// <summary>Helper: put the buffer into a MemoryStream and create a new instance to deserializing into</summary> public static FileDescriptorSet Deserialize(byte[] buffer) { FileDescriptorSet instance = new FileDescriptorSet(); using (var ms = new MemoryStream(buffer)) Deserialize(ms, instance); return instance; }
/// <summary> /// Resolves any dependencies and converts FileDescriptorProtos into FileDescriptors. /// The list returned is in the same order as the protos are listed in the descriptor set. /// Note: this method is internal rather than private to allow testing. /// </summary> /// <exception cref="DependencyResolutionException">Not all dependencies could be resolved.</exception> internal static IList<FileDescriptor> ConvertDescriptors(FileDescriptorSet descriptorProtos) { // Simple strategy: Keep going through the list of protos to convert, only doing ones where // we've already converted all the dependencies, until we get to a stalemate IList<FileDescriptorProto> fileList = descriptorProtos.FileList; FileDescriptor[] converted = new FileDescriptor[fileList.Count]; Dictionary<string, FileDescriptor> convertedMap = new Dictionary<string, FileDescriptor>(); int totalConverted = 0; bool madeProgress = true; while (madeProgress && totalConverted < converted.Length) { madeProgress = false; for (int i = 0; i < converted.Length; i++) { if (converted[i] != null) { // Already done this one continue; } FileDescriptorProto candidate = fileList[i]; FileDescriptor[] dependencies = new FileDescriptor[candidate.DependencyList.Count]; bool foundAllDependencies = true; for (int j = 0; j < dependencies.Length; j++) { if (!convertedMap.TryGetValue(candidate.DependencyList[j], out dependencies[j])) { foundAllDependencies = false; break; } } if (!foundAllDependencies) { continue; } madeProgress = true; totalConverted++; converted[i] = FileDescriptor.BuildFrom(candidate, dependencies); convertedMap[candidate.Name] = converted[i]; } } if (!madeProgress) { StringBuilder remaining = new StringBuilder(); for (int i = 0; i < converted.Length; i++) { if (converted[i] == null) { if (remaining.Length != 0) { remaining.Append(", "); } FileDescriptorProto failure = fileList[i]; remaining.Append(failure.Name); remaining.Append(":"); foreach (string dependency in failure.DependencyList) { if (!convertedMap.ContainsKey(dependency)) { remaining.Append(" "); remaining.Append(dependency); } } remaining.Append(";"); } } throw new DependencyResolutionException("Unable to resolve all dependencies: " + remaining); } return Lists.AsReadOnly(converted); }
/// <summary>Serialize the instance into the stream</summary> public static void Serialize(Stream stream, FileDescriptorSet instance) { var msField = global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Pop(); if (instance.File != null) { foreach (var i1 in instance.File) { // Key for field: 1, LengthDelimited stream.WriteByte(10); msField.SetLength(0); Google.Protobuf.FileDescriptorProto.Serialize(msField, i1); // Length delimited byte array uint length1 = (uint)msField.Length; global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length1); msField.WriteTo(stream); } } global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Push(msField); }
public void CircularDependency() { FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "Second" } }.Build(); FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = { "First" } }.Build(); FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } }; try { Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set); Assert.Fail("Expected exception"); } catch (DependencyResolutionException) { // Expected } }