protobuf 1.4.2 → 2.0.0.rc1

data/.gitignore

@@ -8,5 +8,9 @@ coverage
 doc
 .yardoc
 .DS_Store
+*.so
 *.bin
 Gemfile.lock
+tmp/*
+ext/defs
+ext/out

data/Rakefile

@@ -4,13 +4,6 @@ $:.push File.expand_path("./spec", File.dirname(__FILE__))
 require "bundler/gem_tasks"
 require "benchmark/tasks"
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'test:.'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
 require 'rspec/core/rake_task'
 
 desc 'Default: run specs.'
@@ -18,3 +11,10 @@ task :default => :spec
 
 desc "Run specs"
 RSpec::Core::RakeTask.new(:spec)
+
+## 
+# Rake-compiler
+#
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new("ruby_generator")

data/bin/rpc_server

@@ -1,191 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'optparse'
-require 'ostruct'
-require 'logger'
-require 'protobuf/version'
-require 'protobuf/rpc/servers/evented_runner'
-require 'protobuf/rpc/servers/socket_runner'
-require 'protobuf/rpc/servers/zmq_runner'
+require 'protobuf/cli'
+::Protobuf::CLI.start(ARGV)
 
-# Default options
-server = OpenStruct.new({
-  :app => nil,
-  :env => ENV['RPC_SERVER_ENV'] || 'development',
-  :pre_cache_definitions => false,
-  :gc_pause_during_request => false,
-  :gc_pause_during_serialization => false,
-  :host => '127.0.0.1',
-  :port => 9595,
-  :backlog => 100,
-  :threshold => 100,
-  :log => File.expand_path('./protobuf.log'),
-  :level => ::Logger::INFO,
-  :runner => ::Protobuf::Rpc::EventedRunner, 
-  :debug => false,
-  :stopped_during_startup => false
-})
-
-class ClientServerParse
-  def self.parse_client(value)
-  end
-
-  def self.parse_server(value)
-  end
-end
-
-parser = OptionParser.new do |opts|
-  opts.banner = "Usage: rpc_server [options] app_file.rb"
-
-  opts.on("-e ENVIRONMENT", "--env=ENVIRONMENT", "Environment to run the server") do |v|
-    server.env = ENV['RACK_ENV'] = ENV['RAILS_ENV'] = ENV['APP_ENV'] = v
-  end
-  
-  opts.on("-o HOST", "--host=HOST", "Server host") do |v|
-    server.host = v
-  end
-  
-  opts.on("-p PORT", "--port=PORT", Integer, "Server port") do |v|
-    server.port = v
-  end
-  
-  opts.on("-l LOG_FILE", "--log=LOG_FILE", "Log file or device") do |v|
-    server.log = v
-  end
-  
-  opts.on("-v N", "--level=N", Integer, "Log level to use, 0-5 (see http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/)") do |v|
-    server.level = v.to_i
-  end
-
-  opts.on("-b N", "--backlog=N", Integer, "Backlog for listening socket when using Socket Server") do |v|
-    server.backlog = v.to_i
-  end
-
-  opts.on("-t N", "--threshold=N", Integer, "Multi-threaded Socket Server cleanup threshold") do |v|
-    server.threshold = v.to_i
-  end
-
-  opts.on("-c", "--client_socket", "Socket Mode for client connections (No EventMachine)") do |v|
-    ENV['PB_CLIENT_TYPE'] = "Socket"
-  end
-
-  opts.on("-s", "--socket", "Socket Server Mode (No EventMachine)") do |v|
-    ENV['PB_SERVER_TYPE'] = "Socket"
-    server.runner = ::Protobuf::Rpc::SocketRunner
-  end
-
-  opts.on("-z", "--zmq", "ZeroMQ Socket Mode for client and server connections (they must be used together)") do |v|
-    ENV['PB_CLIENT_TYPE'] = 'Zmq'
-    ENV['PB_SERVER_TYPE'] = 'Zmq'
-
-    server.runner = ::Protobuf::Rpc::ZmqRunner
-  end
-
-  opts.on("--[no-]pre-cache-definitions", "Enable/Disable Message class pre-caching") do |v|
-    server.pre_cache_definitions = v
-  end
-
-  opts.on("--[no-]gc-pause-request", "Enable/Disable GC pause during request.") do |v|
-    server.gc_pause_during_request = v
-  end
-
-  opts.on("--[no-]gc-pause-serialization", "Enable/Disable GC pause during serialization.") do |v|
-    server.gc_pause_during_serialization = v
-  end
-  
-  opts.on("-d", "--[no-]debug", "Debug Mode. Override log level to DEBUG.") do |v|
-    server.debug = v
-    server.level = ::Logger::DEBUG if v === true
-  end
-
-  opts.on("--client-type=PB_CLIENT_TYPE", String, "Client Type to use (Socket or Zmq)") do |v|
-    ENV['PB_CLIENT_TYPE'] = v
-  end
-
-  opts.on("--server-type=PB_SERVER_TYPE", String, "Server Type to use (Socket or Zmq)") do |v|
-    ENV['PB_SERVER_TYPE'] = v
-  end
-
-  opts.separator ""
-  opts.separator "Common options:"
-
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-
-  opts.on_tail("--version", "Show version") do
-    puts ::Protobuf::VERSION
-    exit
-  end
-end
-
-parser.parse!
-
-# Used to ensure we set the PB_CLIENT_TYPE and PB_SERVER_TYPE to the same thing
-# if one of them is set to Zmq
-if(ENV['PB_CLIENT_TYPE'] =~ /zmq/i)
-  # make server and client types the same if we're using Zmq
-  ENV['PB_SERVER_TYPE'] = ENV['PB_CLIENT_TYPE']
-  server.runner = ::Protobuf::Rpc::ZmqRunner
-elsif(ENV['PB_SERVER_TYPE'] =~ /zmq/i)
-  # make server and client types the same if we're using Zmq
-  ENV['PB_CLIENT_TYPE'] = ENV['PB_SERVER_TYPE']
-  server.runner = ::Protobuf::Rpc::ZmqRunner
-elsif(ENV['PB_SERVER_TYPE'] =~ /socket/i)
-  server.runner = ::Protobuf::Rpc::SocketRunner
-end
-
-##
-# Setup GC settings
-# 
-::Protobuf::Rpc::GC_PAUSE_REQUEST = server.gc_pause_during_request
-# If we pause during request we don't need to pause in serialization
-::Protobuf::Rpc::GC_PAUSE_SERIALIZATION = (!server.gc_pause_during_request && server.gc_pause_during_serialization)
-
-# protobuf.rb picks up PB_CLIENT_TYPE and PB_SERVER_TYPE and does something
-# useful with them
-require 'protobuf'
-
-[:INT, :QUIT, :TERM].each do |sig|
-  trap(sig) do
-    server.stopped_during_startup = true
-    server.runner.stop
-  end
-end
-
-begin
-  if ARGV.empty?
-    puts 'You must specify an app file to use.'
-    puts parser.help
-    exit
-  else
-    server.app = ARGV.pop
-    raise 'Invalid app file specified (%s).' % server.app unless File.exists?(server.app)
-  end
-
-  # Configure the ::Protobuf::Logger
-  ::Protobuf::Logger.configure(:file => server.log, :level => server.debug ? ::Logger::DEBUG : server.level)
-
-  # Output the server opts
-  ::Protobuf::Logger.debug { 'Debugging options:' }
-  ::Protobuf::Logger.debug { server.inspect }
-  
-  # Set the name of the process
-  $0 = 'rpc_server %s:%d %s' % [server.host, server.port, server.app]
-  
-  # Require the given application file
-  require server.app unless server.stopped_during_startup
-
-  if server.pre_cache_definitions && !server.stopped_during_startup
-    ::Protobuf::Message.pre_cache_class_definitions 
-  end
-
-  server.runner.run(server) unless server.stopped_during_startup
-rescue
-  msg = 'ERROR: RPC Server failed to start. %s' % $!.inspect
-  $stderr.puts(msg, *($!.backtrace))
-  ::Protobuf::Logger.error { msg }
-  ::Protobuf::Logger.error { $!.backtrace.join("\n") }
-  exit 1
-end

data/bin/rprotoc

@@ -1,46 +1,52 @@
 #!/usr/bin/env ruby
 
-require 'optparse'
+require 'rubygems'
+require 'ffi'
+
+GENERATOR_FILE_PATH = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "ruby_generator.so"))
+unless File.exists?(GENERATOR_FILE_PATH)
+  $stdout << <<-WARNING
+    Cannot locate shared object to plugin to protocol buffers generator.
+    Thought the file would be located at #{GENERATOR_FILE_PATH}
+
+    If you are running on Windows you should compile protocol buffer
+    definitions on another VM and then use those definitions locally.
+
+    Only the compiler is restricted by this.  The definitions should work without issue.
+  WARNING
+  $stdout << $/
 
-if File.directory?("#{File.dirname(__FILE__)}/../lib")
-  $: << "#{File.dirname(__FILE__)}/../lib"
-else
-  require 'rubygems'
-  gem 'protobuf'
-end
-require 'protobuf'
-require 'protobuf/version'
-require 'protobuf/compiler/compiler'
-
-::Version = Protobuf::VERSION
-
-options = {
-  :proto_path => '.',
-  :out => '.',
-}
-opts = OptionParser.new("#{$0} [OPTIONS] PROTO_FILE")
-opts.on('-p', '--proto_path <PATH>', 'Specify the directory in which to search for imports. The current directory is default.'){|v| options[:proto_path] = v}
-opts.on('-o', '--out <OUT_DIR>', 'Specify the directory in which Ruby source file is generated. The current directory is default.'){|v| options[:out] = v}
-opts.on_tail('-v', '--version', 'Show version.'){ puts(opts.ver); exit }
-opts.on_tail('-h', '--help', 'Show this message.'){ puts(opts.help); exit }
-
-begin
-  opts.order!
-rescue OptionParser::ParseError
-  $stderr.puts $!.to_s
   exit 1
 end
 
-unless ARGV.size > 0
-  puts opts
-  exit
-end
+module Protobuf
+  module RProtoC
+    extend FFI::Library
+    ffi_lib ::GENERATOR_FILE_PATH
+    attach_function :_rprotoc_extern, [:int, :pointer], :int32
+
+    def self.compile_proto(args)
+      GC.disable # Don't want strings to be GC'd while protoc has them
+      args = args.dup
+      args.unshift("rprotoc")
+      args << "--help" if args.size == 1
 
-begin
-  ARGV.each do |proto_file|
-    Protobuf::Compiler.compile(proto_file, options[:proto_path], options[:out])
+      ptr_params = []
+      args.each do |param|
+        ptr_params << ::FFI::MemoryPointer.from_string(param.dup)
+      end
+      ptr_params << nil
+
+      argv = ::FFI::MemoryPointer.new(:pointer, ptr_params.size)
+      ptr_params.each_with_index do |param_pointer, index|
+        argv[index].put_pointer(0, param_pointer)
+      end
+
+      self._rprotoc_extern(ptr_params.compact.size, argv)
+    ensure
+      GC.enable
+    end
   end
-rescue
-  $stderr.puts $!.message
-  exit 1
-end
+end
+
+::Protobuf::RProtoC.compile_proto(ARGV)

data/examples/addressbook.pb.rb

@@ -26,7 +26,7 @@
 # }
 
 require 'protobuf/message/message'
-require 'protobuf/message/enum'
+require 'protobuf/enum'
 require 'protobuf/message/extend'
 
 module Tutorial
@@ -52,4 +52,4 @@ module Tutorial
     defined_in __FILE__
     repeated :Person, :person, 1
   end
-end
+end

data/ext/Makefile

@@ -0,0 +1,11 @@
+all: \
+	RubyGenerator.h \
+	RubyGenerator.cpp \
+	main.cpp
+	g++ -Wall -I/code/src/utilities/protobuf-2.4.1/src -lprotoc -lprotobuf -lpthread -o protoc-ruby RubyGenerator.cpp main.cpp
+
+test:
+	rm -rf test/out/*
+	./protoc-ruby --proto_path=defs --ruby_out=out defs/atlas/util.proto defs/atlas/newman/*.proto
+
+.PHONY: all test

data/ext/protobuf-2.4.1/src/google/protobuf/compiler/code_generator.h

@@ -0,0 +1,142 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Defines the abstract interface implemented by each of the language-specific
+// code generators.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace google {
+namespace protobuf {
+
+namespace io { class ZeroCopyOutputStream; }
+class FileDescriptor;
+
+namespace compiler {
+
+// Defined in this file.
+class CodeGenerator;
+class GeneratorContext;
+
+// The abstract interface to a class which generates code implementing a
+// particular proto file in a particular language.  A number of these may
+// be registered with CommandLineInterface to support various languages.
+class LIBPROTOC_EXPORT CodeGenerator {
+ public:
+  inline CodeGenerator() {}
+  virtual ~CodeGenerator();
+
+  // Generates code for the given proto file, generating one or more files in
+  // the given output directory.
+  //
+  // A parameter to be passed to the generator can be specified on the
+  // command line.  This is intended to be used by Java and similar languages
+  // to specify which specific class from the proto file is to be generated,
+  // though it could have other uses as well.  It is empty if no parameter was
+  // given.
+  //
+  // Returns true if successful.  Otherwise, sets *error to a description of
+  // the problem (e.g. "invalid parameter") and returns false.
+  virtual bool Generate(const FileDescriptor* file,
+                        const string& parameter,
+                        GeneratorContext* generator_context,
+                        string* error) const = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodeGenerator);
+};
+
+// CodeGenerators generate one or more files in a given directory.  This
+// abstract interface represents the directory to which the CodeGenerator is
+// to write and other information about the context in which the Generator
+// runs.
+class LIBPROTOC_EXPORT GeneratorContext {
+ public:
+  inline GeneratorContext() {}
+  virtual ~GeneratorContext();
+
+  // Opens the given file, truncating it if it exists, and returns a
+  // ZeroCopyOutputStream that writes to the file.  The caller takes ownership
+  // of the returned object.  This method never fails (a dummy stream will be
+  // returned instead).
+  //
+  // The filename given should be relative to the root of the source tree.
+  // E.g. the C++ generator, when generating code for "foo/bar.proto", will
+  // generate the files "foo/bar.pb.h" and "foo/bar.pb.cc"; note that
+  // "foo/" is included in these filenames.  The filename is not allowed to
+  // contain "." or ".." components.
+  virtual io::ZeroCopyOutputStream* Open(const string& filename) = 0;
+
+  // Creates a ZeroCopyOutputStream which will insert code into the given file
+  // at the given insertion point.  See plugin.proto (plugin.pb.h) for more
+  // information on insertion points.  The default implementation
+  // assert-fails -- it exists only for backwards-compatibility.
+  //
+  // WARNING:  This feature is currently EXPERIMENTAL and is subject to change.
+  virtual io::ZeroCopyOutputStream* OpenForInsert(
+      const string& filename, const string& insertion_point);
+
+  // Returns a vector of FileDescriptors for all the files being compiled
+  // in this run.  Useful for languages, such as Go, that treat files
+  // differently when compiled as a set rather than individually.
+  virtual void ListParsedFiles(vector<const FileDescriptor*>* output);
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GeneratorContext);
+};
+
+// The type GeneratorContext was once called OutputDirectory. This typedef
+// provides backward compatibility.
+typedef GeneratorContext OutputDirectory;
+
+// Several code generators treat the parameter argument as holding a
+// list of options separated by commas.  This helper function parses
+// a set of comma-delimited name/value pairs: e.g.,
+//   "foo=bar,baz,qux=corge"
+// parses to the pairs:
+//   ("foo", "bar"), ("baz", ""), ("qux", "corge")
+extern void ParseGeneratorParameter(const string&,
+            vector<pair<string, string> >*);
+
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__