FROM gcr.io/google_appengine/python

RUN virtualenv /env

ENV VIRTUAL_ENV -p python3.5 /env

ENV PATH /env/bin:$PATH

ADD . /bookstore/

WORKDIR /bookstore

RUN pip install -r requirements.txt

EXPOSE 8000

ENTRYPOINT ["python", "/bookstore/bookstore_server.py"]

virtualenv bookstore-env

source bookstore-env/bin/activate

Install all the Python dependencies:

pip install -r requirements.txt

Install the [gRPC libraries and tools](http://www.grpc.io/docs/quickstart/python.html#prerequisites)

To run the server:

python bookstore_server.py

The `-h` command line flag shows the various settings available.

To run the client:

python bookstore_client.py

As with the server, the `-h` command line flag shows the various settings

available.

The bookstore gRPC API is defined by `bookstore.proto`

The API client stubs and server interfaces are generated by tools.

To make it easier to get something up and running, we've included the generated

code in the sample distribution. To modify the sample or create your own gRPC

API definition, you'll need to update the generated code. To do this, once the

gRPC libraries and tools are installed, run:

python -m grpc.tools.protoc --python_out=generated_pb2 \

--grpc_python_out=generated_pb2 --proto_path=. bookstore.proto

syntax = "proto3";

package endpoints.examples.bookstore;

option java_multiple_files = true;

option java_outer_classname = "BookstoreProto";

option java_package = "com.google.endpoints.examples.bookstore";

import "google/protobuf/empty.proto";

service Bookstore {

// Returns a list of all shelves in the bookstore.

rpc ListShelves(google.protobuf.Empty) returns (ListShelvesResponse) {}

// Creates a new shelf in the bookstore.

rpc CreateShelf(CreateShelfRequest) returns (Shelf) {}

// Returns a specific bookstore shelf.

rpc GetShelf(GetShelfRequest) returns (Shelf) {}

// Deletes a shelf, including all books that are stored on the shelf.

rpc DeleteShelf(DeleteShelfRequest) returns (google.protobuf.Empty) {}

// Returns a list of books on a shelf.

rpc ListBooks(ListBooksRequest) returns (ListBooksResponse) {}

// Creates a new book.

rpc CreateBook(CreateBookRequest) returns (Book) {}

// Returns a specific book.

rpc GetBook(GetBookRequest) returns (Book) {}

// Deletes a book from a shelf.

rpc DeleteBook(DeleteBookRequest) returns (google.protobuf.Empty) {}

}

message Shelf {

// A unique shelf id.

int64 id = 1;

// A theme of the shelf (fiction, poetry, etc).

string theme = 2;

}

message Book {

// A unique book id.

int64 id = 1;

// An author of the book.

string author = 2;

// A book title.

string title = 3;

}

message ListShelvesResponse {

// Shelves in the bookstore.

repeated Shelf shelves = 1;

}

message CreateShelfRequest {

// The shelf resource to create.

Shelf shelf = 1;

}

message GetShelfRequest {

// The ID of the shelf resource to retrieve.

int64 shelf = 1;

}

message DeleteShelfRequest {

// The ID of the shelf to delete.

int64 shelf = 1;

}

message ListBooksRequest {

// ID of the shelf which books to list.

int64 shelf = 1;

}

message ListBooksResponse {

// The books on the shelf.

repeated Book books = 1;

}

message CreateBookRequest {

// The ID of the shelf on which to create a book.

int64 shelf = 1;

// A book resource to create on the shelf.

Book book = 2;

}

message GetBookRequest {

// The ID of the shelf from which to retrieve a book.

int64 shelf = 1;

// The ID of the book to retrieve.

int64 book = 2;

}

message DeleteBookRequest {

// The ID of the shelf from which to delete a book.

int64 shelf = 1;

// The ID of the book to delete.

int64 book = 2;

}

import threading

class ShelfInfo(object):

"""The contents of a single shelf."""

def __init__(self, shelf):

self._shelf = shelf

self._last_book_id = 0

self._books = dict()

class Bookstore(object):

"""An in-memory backend for storing Bookstore data."""

def __init__(self):

self._last_shelf_id = 0

self._shelves = dict()

self._lock = threading.Lock()

def list_shelf(self):

with self._lock:

return [s._shelf for (_, s) in self._shelves.iteritems()]

def create_shelf(self, shelf):

with self._lock:

self._last_shelf_id += 1

shelf_id = self._last_shelf_id

shelf.id = shelf_id

self._shelves[shelf_id] = ShelfInfo(shelf)

return (shelf, shelf_id)

def get_shelf(self, shelf_id):

with self._lock:

return self._shelves[shelf_id]._shelf

def delete_shelf(self, shelf_id):

with self._lock:

del self._shelves[shelf_id]

def list_books(self, shelf_id):

with self._lock:

return [book for (

_, book) in self._shelves[shelf_id]._books.iteritems()]

def create_book(self, shelf_id, book):

with self._lock:

shelf_info = self._shelves[shelf_id]

shelf_info._last_book_id += 1

book_id = shelf_info._last_book_id

book.id = book_id

shelf_info._books[book_id] = book

return book

def get_book(self, shelf_id, book_id):

with self._lock:

return self._shelves[shelf_id]._books[book_id]

def delete_book(self, shelf_id, book_id):

with self._lock:

del self._shelves[shelf_id]._books[book_id]

import argparse

from google.protobuf import empty_pb2

from generated_pb2 import bookstore_pb2

import grpc

def run(host, port, api_key, timeout):

"""Makes a basic ListShelves call against a gRPC Bookstore server."""

channel = grpc.insecure_channel('{}:{}'.format(host, port))

stub = bookstore_pb2.BookstoreStub(channel)

metadata = [('x-api-key', api_key)] if api_key else None

shelves = stub.ListShelves(empty_pb2.Empty(), timeout, metadata=metadata)

print('ListShelves: {}'.format(shelves))

if __name__ == '__main__':

parser = argparse.ArgumentParser(

description=__doc__,

formatter_class=argparse.RawDescriptionHelpFormatter)

parser.add_argument(

'--host', default='localhost', help='The host to connect to')

parser.add_argument(

'--port', type=int, default=8000, help='The port to connect to')

parser.add_argument(

'--timeout', type=int, default=10, help='The call timeout, in seconds')

parser.add_argument(

'--api_key', default=None, help='The API key to use for the call')

args = parser.parse_args()

run(args.host, args.port, args.api_key, args.timeout)