[CORD-2871]
Fix protobuf integration in prep for CORD-2276
Change-Id: Ic614821d17675b1c70fe29bebdd11892bab99a32
diff --git a/containers/xos/pip_requirements.txt b/containers/xos/pip_requirements.txt
index 233c566..3e9b703 100644
--- a/containers/xos/pip_requirements.txt
+++ b/containers/xos/pip_requirements.txt
@@ -38,7 +38,7 @@
djangorestframework==3.7.7
dnslib==0.9.6
docutils==0.13.1
-docker-py==1.10.6
+docker==3.1.4
docker_pycreds==0.2.1
docopt==0.6.2
dogpile.cache==0.6.2
@@ -61,12 +61,12 @@
incremental==16.10.1
iso8601==0.1.11
itypes==1.1.0
-fluent-logger==0.4.4
+fluent-logger==0.9.2
jsonpatch==1.14
jsonpointer==1.10
jsonschema==2.5.1
keystoneauth1==2.12.1
-klein==16.12.0
+klein==17.10.0
kombu==3.0.35
lxml==3.6.4
meld3==0.6.10
diff --git a/lib/xos-genx/setup.py b/lib/xos-genx/setup.py
index 4bb1825..109af47 100644
--- a/lib/xos-genx/setup.py
+++ b/lib/xos-genx/setup.py
@@ -33,4 +33,10 @@
packages=['xosgenx'],
scripts=['bin/xosgenx'],
include_package_data=True,
+ # TODO add all deps to the install_requires section
+ install_requires=[
+ 'pattern>=2.6',
+ 'astunparse>=1.5.0'
+ ]
)
+
diff --git a/lib/xos-genx/xosgenx/targets/protoapi.xtarget b/lib/xos-genx/xosgenx/targets/protoapi.xtarget
index c580764..183bacd 100644
--- a/lib/xos-genx/xosgenx/targets/protoapi.xtarget
+++ b/lib/xos-genx/xosgenx/targets/protoapi.xtarget
@@ -3,7 +3,7 @@
package xos;
import "google/protobuf/empty.proto";
-import "google/api/annotations.proto";
+import "annotations.proto";
import "common.proto";
import "xosoptions.proto";
@@ -50,7 +50,7 @@
{% for object in proto.messages | sort(attribute='name')%}
{% if object.name != 'XOSBase' -%}
rpc List{{ object.name }}(google.protobuf.Empty) returns ({{ xproto_pluralize(object) }}) {
- option (google.api.http) = {
+ option (googleapi.http) = {
{%- if object.name=='CordSubscriberRoot' %}
get: "/xosapi/v1/rcord/{{ xproto_pluralize(object) | lower }}"
{%- else %}
@@ -61,7 +61,7 @@
rpc Filter{{ object.name }}(Query) returns ({{ xproto_pluralize(object) }}) {
}
rpc Get{{ object.name }}(ID) returns ({{ object.name }}) {
- option (google.api.http) = {
+ option (googleapi.http) = {
{%- if object.name=='CordSubscriberRoot' %}
get: "/xosapi/v1/rcord/{{ xproto_pluralize(object) | lower }}/{id}"
{%- else %}
@@ -70,19 +70,19 @@
};
}
rpc Create{{ object.name }}({{ object.name }}) returns ({{ object.name }}) {
- option (google.api.http) = {
+ option (googleapi.http) = {
post: "/xosapi/v1/{{ xproto_unquote(xproto_first_non_empty([object.options.name, object.options.app_label, options.name, context.app_label])) }}/{{ xproto_pluralize(object) | lower }}"
body: "*"
};
}
rpc Update{{ object.name }}({{ object.name }}) returns ({{ object.name }}) {
- option (google.api.http) = {
+ option (googleapi.http) = {
put: "/xosapi/v1/{{ xproto_unquote(xproto_first_non_empty([object.options.name, object.options.app_label, options.name, context.app_label])) }}/{{ xproto_pluralize(object) | lower }}/{id}"
body: "*"
};
}
rpc Delete{{ object.name }}(ID) returns (google.protobuf.Empty) {
- option (google.api.http) = {
+ option (googleapi.http) = {
delete: "/xosapi/v1/{{ xproto_unquote(xproto_first_non_empty([object.options.name, object.options.app_label, options.name, context.app_label])) }}/{{ xproto_pluralize(object) | lower }}/{id}"
};
}
diff --git a/xos/coreapi/env.sh b/xos/coreapi/env.sh
index daa0b7a..4259fad 100644
--- a/xos/coreapi/env.sh
+++ b/xos/coreapi/env.sh
@@ -16,4 +16,4 @@
export XOSGRPC_BASE=$PWD
-export PYTHONPATH=$PYTHONPATH:$XOSGRPC_BASE:$XOSGRPC_BASE/protos/third_party
+export PYTHONPATH=$PYTHONPATH:$XOSGRPC_BASE
diff --git a/xos/coreapi/grpc_server.py b/xos/coreapi/grpc_server.py
index 1450756..d4c73fa 100644
--- a/xos/coreapi/grpc_server.py
+++ b/xos/coreapi/grpc_server.py
@@ -61,9 +61,11 @@
proto_dir = abspath(join(dirname(__file__), './protos'))
def find_files(dir, suffix):
+ proto_blacklist = ['schema.proto']
+
proto_files = [
join(dir, fname) for fname in os.listdir(dir)
- if fname.endswith(suffix)
+ if fname.endswith(suffix) and fname not in proto_blacklist
]
return proto_files
diff --git a/xos/coreapi/protos/Makefile b/xos/coreapi/protos/Makefile
index ea86b39..a30f841 100644
--- a/xos/coreapi/protos/Makefile
+++ b/xos/coreapi/protos/Makefile
@@ -1,4 +1,3 @@
-#
# Copyright 2017 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,39 +15,21 @@
# Makefile to build all protobuf and gRPC related artifacts
-#ifeq ($(VOLTHA_BASE)_set,_set)
-# $(error To get started, please source the env.sh file from Voltha top level directory)
-#endif
-
default: build
-XOS_DIR=/opt/xos
-PROTO_FILES := $(wildcard *.proto) $(wildcard third_party/google/api/*proto)
+PROTO_FILES := $(wildcard *.proto)
PROTO_PB2_FILES := $(foreach f,$(PROTO_FILES),$(subst .proto,_pb2.py,$(f)))
PROTO_DESC_FILES := $(foreach f,$(PROTO_FILES),$(subst .proto,.desc,$(f)))
PROTOC_PREFIX := /usr/local
PROTOC_LIBDIR := $(PROTOC_PREFIX)/lib
-PROTOC := $(PROTOC_PREFIX)/bin/protoc
-
-PROTOC_VERSION := "3.0.2"
-PROTOC_DOWNLOAD_PREFIX := "https://github.com/google/protobuf/releases/download"
-PROTOC_DIR := protobuf-$(PROTOC_VERSION)
-PROTOC_TARBALL := protobuf-python-$(PROTOC_VERSION).tar.gz
-PROTOC_DOWNLOAD_URI := $(PROTOC_DOWNLOAD_PREFIX)/v$(PROTOC_VERSION)/$(PROTOC_TARBALL)
-PROTOC_BUILD_TMP_DIR := "/tmp/protobuf-build-$(shell uname -s | tr '[:upper:]' '[:lower:]')"
-
-XPROTO_FILES := $(wildcard $(XOS_DIR)/core/models/core.xproto $(XOS_DIR)/services/*/*.xproto $(XOS_DIR)/dynamic_services/*/*.xproto)
-XOSGEN_PATH := $(XOS_DIR)/lib/xos-genx/xosgenx
-
-build: $(PROTOC) $(PROTO_PB2_FILES)
+build: $(PROTO_PB2_FILES)
%_pb2.py: %.proto Makefile
@echo "Building protocol buffer artifacts from $<"
env LD_LIBRARY_PATH=$(PROTOC_LIBDIR) python -m grpc.tools.protoc \
-I. \
- -I./third_party \
--python_out=. \
--grpc_python_out=. \
--descriptor_set_out=$(basename $<).desc \
@@ -59,35 +40,15 @@
clean:
rm -f $(PROTO_PB2_FILES) $(PROTO_DESC_FILES)
-$(PROTOC):
- @echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
- @echo "It looks like you don't have protocol buffer tools installed."
- @echo "To install the protocol buffer toolchain, you can run:"
- @echo " make install-protoc"
- @echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+# xproto related targets
-install-protoc: $(PROTOC)
- @echo "Downloading and installing protocol buffer support."
- @echo "Installation will require sodo priviledges"
- @echo "This will take a few minutes."
- mkdir -p $(PROTOC_BUILD_TMP_DIR)
- @echo "We ask for sudo credentials now so we can install at the end"; \
- sudo echo "Thanks"; \
- cd $(PROTOC_BUILD_TMP_DIR); \
- wget $(PROTOC_DOWNLOAD_URI); \
- tar xzvf $(PROTOC_TARBALL); \
- cd $(PROTOC_DIR); \
- ./configure --prefix=$(PROTOC_PREFIX); \
- make; \
- sudo make install
+XOS_DIR=/opt/xos
+XOSGEN_PATH := $(XOS_DIR)/lib/xos-genx/xosgenx
-uninstall-protoc:
- cd $(PROTOC_BUILD_TMP_DIR)/$(PROTOC_DIR); \
- sudo make uninstall
-
-# Note: If you want to generate a new file, you need to do two things: Add a line of the type specified in the following line,
-# and add the generated file to "AUTOGENERATED"
-# <file to be generated>: <xtarget template that it depends on>
+# Note: If you want to generate a new file, you need to do two things: Add a
+# line of the type specified in the following line, and add the generated file
+# to "AUTOGENERATED" <file to be generated>: <xtarget template that it depends
+# on>
$(XOS_DIR)/coreapi/protos/xos.proto: $(XOSGEN_PATH)/targets/protoapi.xtarget
$(XOS_DIR)/coreapi/xos_grpc_api.py: $(XOSGEN_PATH)/targets/grpc_api.xtarget
@@ -97,9 +58,12 @@
AUTOGENERATED=$(XOS_DIR)/coreapi/protos/xos.proto $(XOS_DIR)/coreapi/xos_grpc_api.py $(XOS_DIR)/coreapi/tests/list_test.py $(XOS_DIR)/coreapi/tests/chameleon_list_test.sh $(XOS_DIR)/coreapi/protos/modeldefs.yaml
+XPROTO_FILES := $(wildcard $(XOS_DIR)/core/models/core.xproto $(XOS_DIR)/services/*/*.xproto $(XOS_DIR)/dynamic_services/*/*.xproto)
+
$(AUTOGENERATED):
xosgenx --target $< $(XPROTO_FILES) > $@
rebuild-protos: $(AUTOGENERATED)
.PHONY: $(AUTOGENERATED) rebuild-protos
+
diff --git a/xos/coreapi/protos/third_party/google/api/annotations.proto b/xos/coreapi/protos/annotations.proto
similarity index 75%
rename from xos/coreapi/protos/third_party/google/api/annotations.proto
rename to xos/coreapi/protos/annotations.proto
index cbd18b8..2ed81a6 100644
--- a/xos/coreapi/protos/third_party/google/api/annotations.proto
+++ b/xos/coreapi/protos/annotations.proto
@@ -1,4 +1,5 @@
// Copyright (c) 2015, Google Inc.
+// Modififications (C) 2018, Open Networking Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -12,16 +13,20 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+// See NOTE in http.proto for the modifications made to these files
+
syntax = "proto3";
-package google.api;
+package googleapi;
-import "google/api/http.proto";
+import "http.proto";
import "google/protobuf/descriptor.proto";
+option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations";
option java_multiple_files = true;
option java_outer_classname = "AnnotationsProto";
option java_package = "com.google.api";
+option objc_class_prefix = "GAPI";
extend google.protobuf.MethodOptions {
// See `HttpRule`.
diff --git a/xos/coreapi/protos/dynamicload.proto b/xos/coreapi/protos/dynamicload.proto
index 14dcf87..353804f 100644
--- a/xos/coreapi/protos/dynamicload.proto
+++ b/xos/coreapi/protos/dynamicload.proto
@@ -3,8 +3,7 @@
package xos;
import "google/protobuf/empty.proto";
-import "google/api/annotations.proto";
-// import "common.proto";
+import "annotations.proto";
message Xproto {
string filename = 1;
@@ -56,19 +55,19 @@
service dynamicload {
rpc LoadModels(LoadModelsRequest) returns (LoadModelsReply) {
- option (google.api.http) = {
+ option (googleapi.http) = {
post: "/xosapi/v1/dynamicload/load_models"
body: "*"
};
}
rpc UnloadModels(UnloadModelsRequest) returns (LoadModelsReply) {
- option (google.api.http) = {
+ option (googleapi.http) = {
post: "/xosapi/v1/dynamicload/unload_models"
body: "*"
};
}
rpc GetLoadStatus(google.protobuf.Empty) returns (LoadStatusReply) {
- option (google.api.http) = {
+ option (googleapi.http) = {
get: "/xosapi/v1/dynamicload/load_status"
};
}
diff --git a/xos/coreapi/protos/http.proto b/xos/coreapi/protos/http.proto
new file mode 100644
index 0000000..99d0ce3
--- /dev/null
+++ b/xos/coreapi/protos/http.proto
@@ -0,0 +1,353 @@
+// Copyright 2018 Google LLC
+// Modififications (C) 2018, Open Networking Foundation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// NOTE: On the provenance of and modifications to http.proto and
+// annotations.proto
+//
+// TL;DR: The files http.proto and annotations.proto are originally from here:
+// https://github.com/googleapis/googleapis
+// They have been modified slightly to avoid a namespace conflict.
+//
+// Long winded explanation:
+// These files are designed to interact with Google's first party API's, and
+// the recommended way to use them is to compiled them to code with protoc and
+// included in your codebase before being used. Due to the fact that we're not
+// using them that way, and because of how Chameleon and XOS work (dynamically
+// defining our own API's), we have to ship these *.proto files as a part of
+// our artifacts.
+//
+// The problems start when you try to include these specific .proto files in
+// python. The protoc compiler includes the `google.protobuf` classes, which
+// python can look up in the standard python library path. Unfortunately these
+// files are namespaced with `google.api` in the path and aren't shipped with
+// protoc. This leads to a path conflict - you can't have two library paths
+// start with the same path component (`google` in this case) without getting
+// an "ImportError: No module named ..." on one of the paths when you import
+// them.
+//
+// Historically, various confusing hacks were implemented to override and
+// special-case the python `include` directive to include a file at a different
+// path than was specified. These hacks also failed when updating the base OS,
+// and would likely continue to fail in other, stranger ways as we update the
+// codebase. Specifically, Python 3 reimplemented these features in the
+// importlib section of the standard library, so there's little confidence our
+// hacks would continue to work. As an aside, there are various protobuf
+// `options` statements to deal with this sort of issue in other languages (see
+// the `go_package` and `java_package` below ) but these don't currently exist
+// for python: https://github.com/google/protobuf/issues/973
+//
+// To avoid this entire psychotic namespace hellscape, it's much easier to
+// modify these files to remove the google.api path component, and have them
+// included directly at a path of our own choice.
+
+syntax = "proto3";
+
+package googleapi;
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations";
+option java_multiple_files = true;
+option java_outer_classname = "HttpProto";
+option java_package = "com.google.api";
+option objc_class_prefix = "GAPI";
+
+
+// Defines the HTTP configuration for an API service. It contains a list of
+// [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method
+// to one or more HTTP REST API methods.
+message Http {
+ // A list of HTTP configuration rules that apply to individual API methods.
+ //
+ // **NOTE:** All service configuration rules follow "last one wins" order.
+ repeated HttpRule rules = 1;
+
+ // When set to true, URL path parmeters will be fully URI-decoded except in
+ // cases of single segment matches in reserved expansion, where "%2F" will be
+ // left encoded.
+ //
+ // The default behavior is to not decode RFC 6570 reserved characters in multi
+ // segment matches.
+ bool fully_decode_reserved_expansion = 2;
+}
+
+// `HttpRule` defines the mapping of an RPC method to one or more HTTP
+// REST API methods. The mapping specifies how different portions of the RPC
+// request message are mapped to URL path, URL query parameters, and
+// HTTP request body. The mapping is typically specified as an
+// `google.api.http` annotation on the RPC method,
+// see "google/api/annotations.proto" for details.
+//
+// The mapping consists of a field specifying the path template and
+// method kind. The path template can refer to fields in the request
+// message, as in the example below which describes a REST GET
+// operation on a resource collection of messages:
+//
+//
+// service Messaging {
+// rpc GetMessage(GetMessageRequest) returns (Message) {
+// option (google.api.http).get = "/v1/messages/{message_id}/{sub.subfield}";
+// }
+// }
+// message GetMessageRequest {
+// message SubMessage {
+// string subfield = 1;
+// }
+// string message_id = 1; // mapped to the URL
+// SubMessage sub = 2; // `sub.subfield` is url-mapped
+// }
+// message Message {
+// string text = 1; // content of the resource
+// }
+//
+// The same http annotation can alternatively be expressed inside the
+// `GRPC API Configuration` YAML file.
+//
+// http:
+// rules:
+// - selector: <proto_package_name>.Messaging.GetMessage
+// get: /v1/messages/{message_id}/{sub.subfield}
+//
+// This definition enables an automatic, bidrectional mapping of HTTP
+// JSON to RPC. Example:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456/foo` | `GetMessage(message_id: "123456" sub: SubMessage(subfield: "foo"))`
+//
+// In general, not only fields but also field paths can be referenced
+// from a path pattern. Fields mapped to the path pattern cannot be
+// repeated and must have a primitive (non-message) type.
+//
+// Any fields in the request message which are not bound by the path
+// pattern automatically become (optional) HTTP query
+// parameters. Assume the following definition of the request message:
+//
+//
+// service Messaging {
+// rpc GetMessage(GetMessageRequest) returns (Message) {
+// option (google.api.http).get = "/v1/messages/{message_id}";
+// }
+// }
+// message GetMessageRequest {
+// message SubMessage {
+// string subfield = 1;
+// }
+// string message_id = 1; // mapped to the URL
+// int64 revision = 2; // becomes a parameter
+// SubMessage sub = 3; // `sub.subfield` becomes a parameter
+// }
+//
+//
+// This enables a HTTP JSON to RPC mapping as below:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: "foo"))`
+//
+// Note that fields which are mapped to HTTP parameters must have a
+// primitive type or a repeated primitive type. Message types are not
+// allowed. In the case of a repeated type, the parameter can be
+// repeated in the URL, as in `...?param=A¶m=B`.
+//
+// For HTTP method kinds which allow a request body, the `body` field
+// specifies the mapping. Consider a REST update method on the
+// message resource collection:
+//
+//
+// service Messaging {
+// rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
+// option (google.api.http) = {
+// put: "/v1/messages/{message_id}"
+// body: "message"
+// };
+// }
+// }
+// message UpdateMessageRequest {
+// string message_id = 1; // mapped to the URL
+// Message message = 2; // mapped to the body
+// }
+//
+//
+// The following HTTP JSON to RPC mapping is enabled, where the
+// representation of the JSON in the request body is determined by
+// protos JSON encoding:
+//
+// HTTP | RPC
+// -----|-----
+// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" message { text: "Hi!" })`
+//
+// The special name `*` can be used in the body mapping to define that
+// every field not bound by the path template should be mapped to the
+// request body. This enables the following alternative definition of
+// the update method:
+//
+// service Messaging {
+// rpc UpdateMessage(Message) returns (Message) {
+// option (google.api.http) = {
+// put: "/v1/messages/{message_id}"
+// body: "*"
+// };
+// }
+// }
+// message Message {
+// string message_id = 1;
+// string text = 2;
+// }
+//
+//
+// The following HTTP JSON to RPC mapping is enabled:
+//
+// HTTP | RPC
+// -----|-----
+// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" text: "Hi!")`
+//
+// Note that when using `*` in the body mapping, it is not possible to
+// have HTTP parameters, as all fields not bound by the path end in
+// the body. This makes this option more rarely used in practice of
+// defining REST APIs. The common usage of `*` is in custom methods
+// which don't use the URL at all for transferring data.
+//
+// It is possible to define multiple HTTP methods for one RPC by using
+// the `additional_bindings` option. Example:
+//
+// service Messaging {
+// rpc GetMessage(GetMessageRequest) returns (Message) {
+// option (google.api.http) = {
+// get: "/v1/messages/{message_id}"
+// additional_bindings {
+// get: "/v1/users/{user_id}/messages/{message_id}"
+// }
+// };
+// }
+// }
+// message GetMessageRequest {
+// string message_id = 1;
+// string user_id = 2;
+// }
+//
+//
+// This enables the following two alternative HTTP JSON to RPC
+// mappings:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")`
+// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: "123456")`
+//
+// # Rules for HTTP mapping
+//
+// The rules for mapping HTTP path, query parameters, and body fields
+// to the request message are as follows:
+//
+// 1. The `body` field specifies either `*` or a field path, or is
+// omitted. If omitted, it indicates there is no HTTP request body.
+// 2. Leaf fields (recursive expansion of nested messages in the
+// request) can be classified into three types:
+// (a) Matched in the URL template.
+// (b) Covered by body (if body is `*`, everything except (a) fields;
+// else everything under the body field)
+// (c) All other fields.
+// 3. URL query parameters found in the HTTP request are mapped to (c) fields.
+// 4. Any body sent with an HTTP request can contain only (b) fields.
+//
+// The syntax of the path template is as follows:
+//
+// Template = "/" Segments [ Verb ] ;
+// Segments = Segment { "/" Segment } ;
+// Segment = "*" | "**" | LITERAL | Variable ;
+// Variable = "{" FieldPath [ "=" Segments ] "}" ;
+// FieldPath = IDENT { "." IDENT } ;
+// Verb = ":" LITERAL ;
+//
+// The syntax `*` matches a single path segment. The syntax `**` matches zero
+// or more path segments, which must be the last part of the path except the
+// `Verb`. The syntax `LITERAL` matches literal text in the path.
+//
+// The syntax `Variable` matches part of the URL path as specified by its
+// template. A variable template must not contain other variables. If a variable
+// matches a single path segment, its template may be omitted, e.g. `{var}`
+// is equivalent to `{var=*}`.
+//
+// If a variable contains exactly one path segment, such as `"{var}"` or
+// `"{var=*}"`, when such a variable is expanded into a URL path, all characters
+// except `[-_.~0-9a-zA-Z]` are percent-encoded. Such variables show up in the
+// Discovery Document as `{var}`.
+//
+// If a variable contains one or more path segments, such as `"{var=foo/*}"`
+// or `"{var=**}"`, when such a variable is expanded into a URL path, all
+// characters except `[-_.~/0-9a-zA-Z]` are percent-encoded. Such variables
+// show up in the Discovery Document as `{+var}`.
+//
+// NOTE: While the single segment variable matches the semantics of
+// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2
+// Simple String Expansion, the multi segment variable **does not** match
+// RFC 6570 Reserved Expansion. The reason is that the Reserved Expansion
+// does not expand special characters like `?` and `#`, which would lead
+// to invalid URLs.
+//
+// NOTE: the field paths in variables and in the `body` must not refer to
+// repeated fields or map fields.
+message HttpRule {
+ // Selects methods to which this rule applies.
+ //
+ // Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
+ string selector = 1;
+
+ // Determines the URL pattern is matched by this rules. This pattern can be
+ // used with any of the {get|put|post|delete|patch} methods. A custom method
+ // can be defined using the 'custom' field.
+ oneof pattern {
+ // Used for listing and getting information about resources.
+ string get = 2;
+
+ // Used for updating a resource.
+ string put = 3;
+
+ // Used for creating a resource.
+ string post = 4;
+
+ // Used for deleting a resource.
+ string delete = 5;
+
+ // Used for updating a resource.
+ string patch = 6;
+
+ // The custom pattern is used for specifying an HTTP method that is not
+ // included in the `pattern` field, such as HEAD, or "*" to leave the
+ // HTTP method unspecified for this rule. The wild-card rule is useful
+ // for services that provide content to Web (HTML) clients.
+ CustomHttpPattern custom = 8;
+ }
+
+ // The name of the request field whose value is mapped to the HTTP body, or
+ // `*` for mapping all fields not captured by the path pattern to the HTTP
+ // body. NOTE: the referred field must not be a repeated field and must be
+ // present at the top-level of request message type.
+ string body = 7;
+
+ // Additional HTTP bindings for the selector. Nested bindings must
+ // not contain an `additional_bindings` field themselves (that is,
+ // the nesting may only be one level deep).
+ repeated HttpRule additional_bindings = 11;
+}
+
+// A custom pattern is used for defining custom HTTP verb.
+message CustomHttpPattern {
+ // The name of this custom HTTP verb.
+ string kind = 1;
+
+ // The path matched by this custom verb.
+ string path = 2;
+}
diff --git a/xos/coreapi/protos/modeldefs.proto b/xos/coreapi/protos/modeldefs.proto
index 5eaa126..1df3234 100644
--- a/xos/coreapi/protos/modeldefs.proto
+++ b/xos/coreapi/protos/modeldefs.proto
@@ -3,7 +3,7 @@
package xos;
import "google/protobuf/empty.proto";
-import "google/api/annotations.proto";
+import "annotations.proto";
// This API is used by the UI to validate fields.
@@ -54,7 +54,7 @@
service modeldefs {
rpc ListModelDefs(google.protobuf.Empty) returns (ModelDefs) {
- option (google.api.http) = {
+ option (googleapi.http) = {
get: "/xosapi/v1/modeldefs"
};
}
diff --git a/xos/coreapi/protos/schema.proto b/xos/coreapi/protos/schema.proto
index 1023f1a..d6e4e01 100644
--- a/xos/coreapi/protos/schema.proto
+++ b/xos/coreapi/protos/schema.proto
@@ -2,8 +2,8 @@
package schema;
-import "google/api/annotations.proto";
import "google/protobuf/empty.proto";
+import "annotations.proto";
// Contains the name and content of a *.proto file
message ProtoFile {
@@ -30,7 +30,7 @@
// Return active grpc schemas
rpc GetSchema(google.protobuf.Empty) returns (Schemas) {
- option (google.api.http) = {
+ option (googleapi.http) = {
get: "/schema"
};
}
diff --git a/xos/coreapi/protos/third_party/__init__.py b/xos/coreapi/protos/third_party/__init__.py
deleted file mode 100644
index c3ed936..0000000
--- a/xos/coreapi/protos/third_party/__init__.py
+++ /dev/null
@@ -1,66 +0,0 @@
-
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-"""
-This helps loading http_pb2 and annotations_pb2.
-Without this, the Python importer will not be able to process the lines:
-from google.api import http_pb2 or
-from google.api import annotations_pb2
-(Without importing these, the protobuf loader will not recognize http options
-in the protobuf definitions.)
-"""
-
-from importlib import import_module
-import os
-import sys
-
-
-class GoogleApiImporter(object):
-
- def find_module(self, full_name, path=None):
- if full_name == 'google.api':
- self.path = [os.path.dirname(__file__)]
- return self
-
- def load_module(self, name):
- if name in sys.modules:
- return sys.modules[name]
- full_name = 'voltha.protos.third_party.' + name
- import_module(full_name)
- module = sys.modules[full_name]
- sys.modules[name] = module
- return module
-
-
-sys.meta_path.append(GoogleApiImporter())
-from google.api import http_pb2, annotations_pb2
-_ = http_pb2, annotations_pb2
diff --git a/xos/coreapi/protos/third_party/google/LICENSE b/xos/coreapi/protos/third_party/google/LICENSE
deleted file mode 100644
index 261eeb9..0000000
--- a/xos/coreapi/protos/third_party/google/LICENSE
+++ /dev/null
@@ -1,201 +0,0 @@
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
- Copyright [yyyy] [name of copyright owner]
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
diff --git a/xos/coreapi/protos/third_party/google/__init__.py b/xos/coreapi/protos/third_party/google/__init__.py
deleted file mode 100644
index d4e8062..0000000
--- a/xos/coreapi/protos/third_party/google/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
diff --git a/xos/coreapi/protos/third_party/google/api/__init__.py b/xos/coreapi/protos/third_party/google/api/__init__.py
deleted file mode 100644
index d4e8062..0000000
--- a/xos/coreapi/protos/third_party/google/api/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
diff --git a/xos/coreapi/protos/third_party/google/api/http.proto b/xos/coreapi/protos/third_party/google/api/http.proto
deleted file mode 100644
index ce07aa1..0000000
--- a/xos/coreapi/protos/third_party/google/api/http.proto
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright (c) 2015, Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-syntax = "proto3";
-
-package google.api;
-
-option java_multiple_files = true;
-option java_outer_classname = "HttpProto";
-option java_package = "com.google.api";
-
-
-// `HttpRule` defines the mapping of an RPC method to one or more HTTP REST API
-// methods. The mapping determines what portions of the request message are
-// populated from the path, query parameters, or body of the HTTP request. The
-// mapping is typically specified as an `google.api.http` annotation, see
-// "google/api/annotations.proto" for details.
-//
-// The mapping consists of a mandatory field specifying a path template and an
-// optional `body` field specifying what data is represented in the HTTP request
-// body. The field name for the path indicates the HTTP method. Example:
-//
-// ```
-// package google.storage.v2;
-//
-// import "google/api/annotations.proto";
-//
-// service Storage {
-// rpc CreateObject(CreateObjectRequest) returns (Object) {
-// option (google.api.http) {
-// post: "/v2/{bucket_name=buckets/*}/objects"
-// body: "object"
-// };
-// };
-// }
-// ```
-//
-// Here `bucket_name` and `object` bind to fields of the request message
-// `CreateObjectRequest`.
-//
-// The rules for mapping HTTP path, query parameters, and body fields
-// to the request message are as follows:
-//
-// 1. The `body` field specifies either `*` or a field path, or is
-// omitted. If omitted, it assumes there is no HTTP body.
-// 2. Leaf fields (recursive expansion of nested messages in the
-// request) can be classified into three types:
-// (a) Matched in the URL template.
-// (b) Covered by body (if body is `*`, everything except (a) fields;
-// else everything under the body field)
-// (c) All other fields.
-// 3. URL query parameters found in the HTTP request are mapped to (c) fields.
-// 4. Any body sent with an HTTP request can contain only (b) fields.
-//
-// The syntax of the path template is as follows:
-//
-// Template = "/" Segments [ Verb ] ;
-// Segments = Segment { "/" Segment } ;
-// Segment = "*" | "**" | LITERAL | Variable ;
-// Variable = "{" FieldPath [ "=" Segments ] "}" ;
-// FieldPath = IDENT { "." IDENT } ;
-// Verb = ":" LITERAL ;
-//
-// `*` matches a single path component, `**` zero or more path components, and
-// `LITERAL` a constant. A `Variable` can match an entire path as specified
-// again by a template; this nested template must not contain further variables.
-// If no template is given with a variable, it matches a single path component.
-// The notation `{var}` is henceforth equivalent to `{var=*}`.
-//
-// Use CustomHttpPattern to specify any HTTP method that is not included in the
-// pattern field, such as HEAD, or "*" to leave the HTTP method unspecified for
-// a given URL path rule. The wild-card rule is useful for services that provide
-// content to Web (HTML) clients.
-message HttpRule {
-
- // Determines the URL pattern is matched by this rules. This pattern can be
- // used with any of the {get|put|post|delete|patch} methods. A custom method
- // can be defined using the 'custom' field.
- oneof pattern {
- // Used for listing and getting information about resources.
- string get = 2;
-
- // Used for updating a resource.
- string put = 3;
-
- // Used for creating a resource.
- string post = 4;
-
- // Used for deleting a resource.
- string delete = 5;
-
- // Used for updating a resource.
- string patch = 6;
-
- // Custom pattern is used for defining custom verbs.
- CustomHttpPattern custom = 8;
- }
-
- // The name of the request field whose value is mapped to the HTTP body, or
- // `*` for mapping all fields not captured by the path pattern to the HTTP
- // body.
- string body = 7;
-
- // Additional HTTP bindings for the selector. Nested bindings must not
- // specify a selector and must not contain additional bindings.
- repeated HttpRule additional_bindings = 11;
-}
-
-// A custom pattern is used for defining custom HTTP verb.
-message CustomHttpPattern {
- // The name of this custom HTTP verb.
- string kind = 1;
-
- // The path matched by this custom verb.
- string path = 2;
-}
diff --git a/xos/coreapi/protos/utility.proto b/xos/coreapi/protos/utility.proto
index 073eb81..554e0a9 100644
--- a/xos/coreapi/protos/utility.proto
+++ b/xos/coreapi/protos/utility.proto
@@ -3,7 +3,7 @@
package xos;
import "google/protobuf/empty.proto";
-import "google/api/annotations.proto";
+import "annotations.proto";
import "common.proto";
import "xosoptions.proto";
@@ -57,55 +57,55 @@
service utility {
rpc Login(LoginRequest) returns (LoginResponse) {
- option (google.api.http) = {
+ option (googleapi.http) = {
post: "/xosapi/v1/utility/login"
body: "*"
};
}
rpc Logout(google.protobuf.Empty) returns (google.protobuf.Empty) {
- option (google.api.http) = {
+ option (googleapi.http) = {
post: "/xosapi/v1/utility/logout"
body: "*"
};
}
rpc NoOp(google.protobuf.Empty) returns (google.protobuf.Empty) {
- option (google.api.http) = {
+ option (googleapi.http) = {
post: "/xosapi/v1/utility/noop"
body: "*"
};
}
rpc AuthenticatedNoOp(google.protobuf.Empty) returns (google.protobuf.Empty) {
- option (google.api.http) = {
+ option (googleapi.http) = {
post: "/xosapi/v1/utility/auth_noop"
body: "*"
};
}
rpc SetDirtyModels(ModelFilter) returns (ModelList) {
- option (google.api.http) = {
+ option (googleapi.http) = {
post: "/xosapi/v1/utility/dirty_models"
body: "*"
};
}
rpc ListDirtyModels(ModelFilter) returns (ModelList) {
- option (google.api.http) = {
+ option (googleapi.http) = {
get: "/xosapi/v1/utility/dirty_models"
};
}
rpc GetXproto(google.protobuf.Empty) returns (XProtos) {
- option (google.api.http) = {
+ option (googleapi.http) = {
get: "/xosapi/v1/xproto"
};
}
rpc GetPopulatedServiceInstances(ID) returns (PopulatedServiceInstance) {
- option (google.api.http) = {
+ option (googleapi.http) = {
get: "/xosapi/v1/core/populatedserviceinstance/{id}"
};
}
-};
\ No newline at end of file
+};
diff --git a/xos/synchronizers/new_base/modelaccessor.py b/xos/synchronizers/new_base/modelaccessor.py
index f917612..6730879 100644
--- a/xos/synchronizers/new_base/modelaccessor.py
+++ b/xos/synchronizers/new_base/modelaccessor.py
@@ -28,6 +28,7 @@
import importlib
import os
import signal
+import sys
import time
from xosconfig import Config
from diag import update_diag
@@ -150,8 +151,9 @@
# So reconnect.
log.exception("exception in NoOp", e=e)
- client.connected = False
- client.connect()
+ log.info("restarting synchronizer")
+
+ os.execv(sys.executable, ['python'] + sys.argv)
return
reactor.callLater(1, functools.partial(keep_trying, client, reactor))
diff --git a/xos/xos_client/setup.py b/xos/xos_client/setup.py
index 1c52a1a..49afcaf 100644
--- a/xos/xos_client/setup.py
+++ b/xos/xos_client/setup.py
@@ -53,17 +53,13 @@
package_dir= {'xosapi.chameleon': CHAMELEON_DIR},
packages=['xosapi.chameleon.grpc_client',
'xosapi.chameleon.protos',
- 'xosapi.chameleon.protos.third_party',
- 'xosapi.chameleon.protos.third_party.google',
- 'xosapi.chameleon.protos.third_party.google.api',
'xosapi.chameleon.utils',
'xosapi.chameleon.protoc_plugins',
'xosapi',
'xosapi.convenience'],
py_modules= ['xosapi.chameleon.__init__'],
include_package_data=True,
- package_data = {'xosapi.chameleon.protos.third_party.google.api': ['*.proto'],
- 'xosapi.chameleon.protos': ['*.proto'],
+ package_data = {'xosapi.chameleon.protos': ['*.proto'],
'xosapi.chameleon.protoc_plugins': ['*.desc']},
scripts = ['xossh'],
)
diff --git a/xos/xos_client/xosapi/xos_grpc_client.py b/xos/xos_client/xosapi/xos_grpc_client.py
index 8a7476e..46fb829 100644
--- a/xos/xos_client/xosapi/xos_grpc_client.py
+++ b/xos/xos_client/xosapi/xos_grpc_client.py
@@ -73,9 +73,9 @@
try:
sys.path.append(self.work_dir)
m_protos = __import__(api + "_pb2")
- reload(m_protos)
+ # reload(m_protos)
m_grpc = __import__(api + "_pb2_grpc")
- reload(m_grpc)
+ # reload(m_grpc)
finally:
sys.path = orig_sys_path