blob.pb.go

// Code generated by protoc-gen-go.
// source: blob.proto
// DO NOT EDIT!

/*
Package main is a generated protocol buffer package.

It is generated from these files:
	blob.proto

It has these top-level messages:
	Request
	Response
*/
package main

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

type Request struct {
	Filename string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"`
}

func (m *Request) Reset()         { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage()    {}

type Response struct {
	Filename string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"`
}

func (m *Response) Reset()         { *m = Response{} }
func (m *Response) String() string { return proto.CompactTextString(m) }
func (*Response) ProtoMessage()    {}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// Client API for Blob service

type BlobClient interface {
	Store(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
}

type blobClient struct {
	cc *grpc.ClientConn
}

func NewBlobClient(cc *grpc.ClientConn) BlobClient {
	return &blobClient{cc}
}

func (c *blobClient) Store(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := grpc.Invoke(ctx, "/main.Blob/Store", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Blob service

type BlobServer interface {
	Store(context.Context, *Request) (*Response, error)
}

func RegisterBlobServer(s *grpc.Server, srv BlobServer) {
	s.RegisterService(&_Blob_serviceDesc, srv)
}

func _Blob_Store_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(Request)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(BlobServer).Store(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

var _Blob_serviceDesc = grpc.ServiceDesc{
	ServiceName: "main.Blob",
	HandlerType: (*BlobServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Store",
			Handler:    _Blob_Store_Handler,
		},
	},
	Streams: []grpc.StreamDesc{},
}

blob.proto

syntax = "proto3";

package main;

message Request {
  string filename = 1;
}

message Response {
  string filename = 1;
}

service Blob {
  rpc Store(Request) returns (Response) {}
}

blob_pb2.py

# Generated by the protocol buffer compiler.  DO NOT EDIT!
# source: blob.proto

from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobuf import reflection as _reflection
from google.protobuf import symbol_database as _symbol_database
from google.protobuf import descriptor_pb2
# @@protoc_insertion_point(imports)

_sym_db = _symbol_database.Default()




DESCRIPTOR = _descriptor.FileDescriptor(
  name='blob.proto',
  package='main',
  syntax='proto3',
  serialized_pb=b'\n\nblob.proto\x12\x04main\"\x1b\n\x07Request\x12\x10\n\x08\x66ilename\x18\x01 \x01(\t\"\x1c\n\x08Response\x12\x10\n\x08\x66ilename\x18\x01 \x01(\t20\n\x04\x42lob\x12(\n\x05Store\x12\r.main.Request\x1a\x0e.main.Response\"\x00\x62\x06proto3'
)
_sym_db.RegisterFileDescriptor(DESCRIPTOR)




_REQUEST = _descriptor.Descriptor(
  name='Request',
  full_name='main.Request',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    _descriptor.FieldDescriptor(
      name='filename', full_name='main.Request.filename', index=0,
      number=1, type=9, cpp_type=9, label=1,
      has_default_value=False, default_value=b"".decode('utf-8'),
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
  ],
  extensions=[
  ],
  nested_types=[],
  enum_types=[
  ],
  options=None,
  is_extendable=False,
  syntax='proto3',
  extension_ranges=[],
  oneofs=[
  ],
  serialized_start=20,
  serialized_end=47,
)


_RESPONSE = _descriptor.Descriptor(
  name='Response',
  full_name='main.Response',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    _descriptor.FieldDescriptor(
      name='filename', full_name='main.Response.filename', index=0,
      number=1, type=9, cpp_type=9, label=1,
      has_default_value=False, default_value=b"".decode('utf-8'),
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
  ],
  extensions=[
  ],
  nested_types=[],
  enum_types=[
  ],
  options=None,
  is_extendable=False,
  syntax='proto3',
  extension_ranges=[],
  oneofs=[
  ],
  serialized_start=49,
  serialized_end=77,
)

DESCRIPTOR.message_types_by_name['Request'] = _REQUEST
DESCRIPTOR.message_types_by_name['Response'] = _RESPONSE

Request = _reflection.GeneratedProtocolMessageType('Request', (_message.Message,), dict(
  DESCRIPTOR = _REQUEST,
  __module__ = 'blob_pb2'
  # @@protoc_insertion_point(class_scope:main.Request)
  ))
_sym_db.RegisterMessage(Request)

Response = _reflection.GeneratedProtocolMessageType('Response', (_message.Message,), dict(
  DESCRIPTOR = _RESPONSE,
  __module__ = 'blob_pb2'
  # @@protoc_insertion_point(class_scope:main.Response)
  ))
_sym_db.RegisterMessage(Response)


import abc
from grpc.beta import implementations as beta_implementations
from grpc.early_adopter import implementations as early_adopter_implementations
from grpc.framework.alpha import utilities as alpha_utilities
from grpc.framework.common import cardinality
from grpc.framework.interfaces.face import utilities as face_utilities
class EarlyAdopterBlobServicer(object):
  """<fill me in later!>"""
  __metaclass__ = abc.ABCMeta
  @abc.abstractmethod
  def Store(self, request, context):
    raise NotImplementedError()
class EarlyAdopterBlobServer(object):
  """<fill me in later!>"""
  __metaclass__ = abc.ABCMeta
  @abc.abstractmethod
  def start(self):
    raise NotImplementedError()
  @abc.abstractmethod
  def stop(self):
    raise NotImplementedError()
class EarlyAdopterBlobStub(object):
  """<fill me in later!>"""
  __metaclass__ = abc.ABCMeta
  @abc.abstractmethod
  def Store(self, request):
    raise NotImplementedError()
  Store.async = None
def early_adopter_create_Blob_server(servicer, port, private_key=None, certificate_chain=None):
  import blob_pb2
  import blob_pb2
  method_service_descriptions = {
    "Store": alpha_utilities.unary_unary_service_description(
      servicer.Store,
      blob_pb2.Request.FromString,
      blob_pb2.Response.SerializeToString,
    ),
  }
  return early_adopter_implementations.server("main.Blob", method_service_descriptions, port, private_key=private_key, certificate_chain=certificate_chain)
def early_adopter_create_Blob_stub(host, port, metadata_transformer=None, secure=False, root_certificates=None, private_key=None, certificate_chain=None, server_host_override=None):
  import blob_pb2
  import blob_pb2
  method_invocation_descriptions = {
    "Store": alpha_utilities.unary_unary_invocation_description(
      blob_pb2.Request.SerializeToString,
      blob_pb2.Response.FromString,
    ),
  }
  return early_adopter_implementations.stub("main.Blob", method_invocation_descriptions, host, port, metadata_transformer=metadata_transformer, secure=secure, root_certificates=root_certificates, private_key=private_key, certificate_chain=certificate_chain, server_host_override=server_host_override)

class BetaBlobServicer(object):
  """<fill me in later!>"""
  __metaclass__ = abc.ABCMeta
  @abc.abstractmethod
  def Store(self, request, context):
    raise NotImplementedError()

class BetaBlobStub(object):
  """The interface to which stubs will conform."""
  __metaclass__ = abc.ABCMeta
  @abc.abstractmethod
  def Store(self, request, timeout):
    raise NotImplementedError()
  Store.future = None

def beta_create_Blob_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):
  import blob_pb2
  import blob_pb2
  request_deserializers = {
    ('main.Blob', 'Store'): blob_pb2.Request.FromString,
  }
  response_serializers = {
    ('main.Blob', 'Store'): blob_pb2.Response.SerializeToString,
  }
  method_implementations = {
    ('main.Blob', 'Store'): face_utilities.unary_unary_inline(servicer.Store),
  }
  server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout)
  return beta_implementations.server(method_implementations, options=server_options)

def beta_create_Blob_stub(channel, host=None, metadata_transformer=None, pool=None, pool_size=None):
  import blob_pb2
  import blob_pb2
  request_serializers = {
    ('main.Blob', 'Store'): blob_pb2.Request.SerializeToString,
  }
  response_deserializers = {
    ('main.Blob', 'Store'): blob_pb2.Response.FromString,
  }
  cardinalities = {
    'Store': cardinality.Cardinality.UNARY_UNARY,
  }
  stub_options = beta_implementations.stub_options(host=host, metadata_transformer=metadata_transformer, request_serializers=request_serializers, response_deserializers=response_deserializers, thread_pool=pool, thread_pool_size=pool_size)
  return beta_implementations.dynamic_stub(channel, 'main.Blob', cardinalities, options=stub_options)
# @@protoc_insertion_point(module_scope)

client.py

import sys
import blob_pb2

from grpc.beta import implementations
from grpc.framework.face import exceptions

channel = implementations.insecure_channel('localhost', 8200)
client = blob_pb2.beta_create_Blob_stub(channel)

try:
    client.Store(blob_pb2.Request(), 1)
except:
    e = sys.exc_info()[0]
    print e.message
    print e.args

Makefile

all: blob_pb2.py blob.pb.go

blob.pb.go: blob.proto
	protoc blob.proto --go_out=plugins=grpc:.

blob_pb2.py: blob.proto
	protoc --python_out=. --grpc_out=. \
			--plugin=protoc-gen-grpc=`which grpc_python_plugin` blob.proto

server.go

package main

import (
	"log"
	"net"

	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
)

type BlobService struct {
}

func (bs *BlobService) Store(c context.Context, r *Request) (*Response, error) {
	return nil, grpc.Errorf(codes.PermissionDenied, "Not authorized")
}

func main() {
	lis, err := net.Listen("tcp", ":8200")
	if err != nil {
		log.Fatal(err)
	}

	blob := BlobService{}

	s := grpc.NewServer()
	RegisterBlobServer(s, &blob)
	err = s.Serve(lis)
	if err != nil {
		log.Fatal(err)
	}
}