def make_stub(client, stub_factory, host, port): """Makes a stub for an RPC service. Uses / depends on the beta implementation of gRPC. :type client: :class:`.client.Client` :param client: The client that owns the cluster. Provides authorization and user agent. :type stub_factory: callable :param stub_factory: A factory which will create a gRPC stub for a given service. :type host: str :param host: The host for the service. :type port: int :param port: The port for the service. :rtype: :class:`grpc.beta._stub._AutoIntermediary` :returns: The stub object used to make gRPC requests to a given API. """ root_certificates = get_certs() client_credentials = implementations.ssl_client_credentials( root_certificates, private_key=None, certificate_chain=None) channel = implementations.secure_channel( host, port, client_credentials) custom_metadata_transformer = MetadataTransformer(client) return stub_factory(channel, metadata_transformer=custom_metadata_transformer)
def _make_stub(client, stub_factory, host, port): """Makes a stub for an RPC service. Uses / depends on the beta implementation of gRPC. :type client: :class:`.client.Client` :param client: The client that owns the instance. Provides authorization and user agent. :type stub_factory: callable :param stub_factory: A factory which will create a gRPC stub for a given service. :type host: str :param host: The host for the service. :type port: int :param port: The port for the service. :rtype: :class:`grpc.beta._stub._AutoIntermediary` :returns: The stub object used to make gRPC requests to a given API. """ # Leaving the first argument to ssl_channel_credentials() as None # loads root certificates from `grpc/_adapter/credentials/roots.pem`. transport_creds = implementations.ssl_channel_credentials(None, None, None) custom_metadata_plugin = _MetadataPlugin(client) auth_creds = implementations.metadata_call_credentials( custom_metadata_plugin, name='google_creds') channel_creds = implementations.composite_channel_credentials( transport_creds, auth_creds) channel = implementations.secure_channel(host, port, channel_creds) return stub_factory(channel)
def do_inference(): # get deployed model details model_name = request.path[1:] query_string = {"modelName": model_name} headers = { 'Authorization': get_access_token(), 'Cache-Control': "no-cache" } res = requests.request("GET", deployment_url, headers=headers, params=query_string) model_info = json.loads(res.text) # check model is available if int(model_info["count"]) < 1: return Response('404 Not Found: Model ' + model_name + ' is unavailable.', status=404) else: # get details for the latest model version latest_version = [0, 0] for index, model in enumerate(model_info["modelServers"]): if int(model["specs"]["models"][0] ["modelVersion"]) > latest_version[0]: latest_version = [ int(model["specs"]["models"][0]["modelVersion"]), index ] model_host = model_info["modelServers"][ latest_version[1]]["endpoints"][0] credentials = implementations.ssl_channel_credentials( root_certificates=str(model_host["caCrt"])) channel = implementations.secure_channel(str(model_host["host"]), int(model_host["port"]), credentials) stub = prediction_service_pb2.beta_create_PredictionService_stub( channel, metadata_transformer=metadata_transformer) # check file was uploaded if not 'file' in globals.request.files: return Response('404 Not Found: File not provided.', status=404) else: # perform inference on the file data = skimage.io.imread(globals.request.files['file']) req = predict_pb2.PredictRequest() req.model_spec.name = model_name req.model_spec.signature_name = 'predict_images' req.inputs["images"].CopyFrom( tf.contrib.util.make_tensor_proto(data, shape=[1, data.size], dtype="float32")) res = stub.Predict(req, 150) # convert scores to JSON res = str(res).split('}')[3].split('\n') res.pop(11) res.pop(0) scores = {} for i, estimate in enumerate(res): scores[str(i)] = float(estimate[14:]) return Response(json.dumps(scores), status=200, mimetype='application/json')
def make_stub(client, stub_factory, host, port): """Makes a stub for an RPC service. Uses / depends on the beta implementation of gRPC. :type client: :class:`.client.Client` :param client: The client that owns the cluster. Provides authorization and user agent. :type stub_factory: callable :param stub_factory: A factory which will create a gRPC stub for a given service. :type host: str :param host: The host for the service. :type port: int :param port: The port for the service. :rtype: :class:`grpc.beta._stub._AutoIntermediary` :returns: The stub object used to make gRPC requests to a given API. """ root_certificates = get_certs() client_credentials = implementations.ssl_client_credentials( root_certificates, private_key=None, certificate_chain=None) channel = implementations.secure_channel(host, port, client_credentials) custom_metadata_transformer = MetadataTransformer(client) return stub_factory(channel, metadata_transformer=custom_metadata_transformer)
def _make_stub(client, stub_factory, host, port): """Makes a stub for an RPC service. Uses / depends on the beta implementation of gRPC. :type client: :class:`.client.Client` :param client: The client that owns the cluster. Provides authorization and user agent. :type stub_factory: callable :param stub_factory: A factory which will create a gRPC stub for a given service. :type host: str :param host: The host for the service. :type port: int :param port: The port for the service. :rtype: :class:`grpc.beta._stub._AutoIntermediary` :returns: The stub object used to make gRPC requests to a given API. """ # Leaving the first argument to ssl_channel_credentials() as None # loads root certificates from `grpc/_adapter/credentials/roots.pem`. transport_creds = implementations.ssl_channel_credentials(None, None, None) custom_metadata_plugin = _MetadataPlugin(client) auth_creds = implementations.metadata_call_credentials( custom_metadata_plugin, name='google_creds') channel_creds = implementations.composite_channel_credentials( transport_creds, auth_creds) channel = implementations.secure_channel(host, port, channel_creds) return stub_factory(channel)
def create_trace_stub(host=TRACE_ENDPOINT, port=SSL_PORT): """Creates a secure channel.""" ssl_creds = implementations.ssl_channel_credentials(None, None, None) call_creds = implementations.metadata_call_credentials(make_auth_func()) channel_creds = implementations.composite_channel_credentials(ssl_creds, call_creds) channel = implementations.secure_channel(host, port, channel_creds) return trace_pb2.beta_create_TraceService_stub(channel)
def make_channel(host, port): ssl_channel = implementations.ssl_channel_credentials(None, None, None) creds = get_credentials().create_scoped(args.speech_scope) auth_header = ("authorization", "Bearer " + creds.get_access_token().access_token) auth_plugin = implementations.metadata_call_credentials(lambda _, func: func([auth_header], None), name="google_creds") composite_channel = implementations.composite_channel_credentials(ssl_channel, auth_plugin) return implementations.secure_channel(host, port, composite_channel)
def make_stub(credentials, user_agent, stub_factory, host, port): """Makes a stub for an RPC service. Uses / depends on the beta implementation of gRPC. :type credentials: :class:`oauth2client.client.OAuth2Credentials` :param credentials: The OAuth2 Credentials to use for creating access tokens. :type user_agent: str :param user_agent: (Optional) The user agent to be used with API requests. :type stub_factory: callable :param stub_factory: A factory which will create a gRPC stub for a given service. :type host: str :param host: The host for the service. :type port: int :param port: The port for the service. :rtype: :class:`grpc.beta._stub._AutoIntermediary` :returns: The stub object used to make gRPC requests to a given API. """ # Leaving the first argument to ssl_channel_credentials() as None # loads root certificates from `grpc/_adapter/credentials/roots.pem`. transport_creds = implementations.ssl_channel_credentials(None, None, None) custom_metadata_plugin = MetadataPlugin(credentials, user_agent) auth_creds = implementations.metadata_call_credentials( custom_metadata_plugin, name='google_creds') channel_creds = implementations.composite_channel_credentials( transport_creds, auth_creds) channel = implementations.secure_channel(host, port, channel_creds) return stub_factory(channel)
def create_stub(generated_create_stub, service_path, port, ssl_creds=None, channel=None, metadata_transformer=None, scopes=None): """Creates a gRPC client stub. Args: generated_create_stub: The generated gRPC method to create a stub. service_path: The domain name of the API remote host. port: The port on which to connect to the remote host. ssl_creds: A ClientCredentials object for use with an SSL-enabled Channel. If none, credentials are pulled from a default location. channel: A Channel object through which to make calls. If none, a secure channel is constructed. metadata_transformer: A function that transforms the metadata for requests, e.g., to give OAuth credentials. scopes: The OAuth scopes for this service. This parameter is ignored if a custom metadata_transformer is supplied. Returns: A gRPC client stub. """ if channel is None: if ssl_creds is None: ssl_creds = implementations.ssl_channel_credentials( None, None, None) if metadata_transformer is None: if scopes is None: scopes = [] metadata_transformer = auth.make_auth_func(scopes) channel_creds = _make_channel_creds(metadata_transformer, ssl_creds) channel = implementations.secure_channel( service_path, port, channel_creds) return generated_create_stub(channel)
def run(): # TSL连接方式 >>> with open( 'G:\DotNet\SevenTiny.Cloud.FaaS\Code\Python\SevenTiny.Cloud.FaaS.GRpc\ca\client.pem', 'rb') as f: pem = f.read() creds = implementations.ssl_channel_credentials(pem, None, None) channel = implementations.secure_channel('localhost', 5001, creds) # TSL连接方式 <<< # 连接 rpc 服务器 # channel = grpc.insecure_channel('localhost:5001') # 调用 rpc 服务 stub = seventiny_cloud_faas_pb2_grpc.DynamicScriptExecutorStub(channel) response = stub.CheckScript( seventiny_cloud_faas_proto_pb2.DynamicScript(TenantId=100000, Script='123123123')) print("CheckScript client received: " + response.Message) response = stub.Execute( seventiny_cloud_faas_proto_pb2.DynamicScript(TenantId=100000, Script='123123123')) print("Execute client received: " + response.Message)
def run(): creds = implementations.ssl_channel_credentials(open('../../../cert.pem' ).read(), None, None) channel = implementations.secure_channel('localhost', 8000, creds) stub = search_pb2.beta_create_Google_stub(channel) search = raw_input('Google: ') query = search_pb2.Request(query=search) results = stub.Search.future(query, _TIMEOUT_) for result in results: print result.title + '\n' + result.url + '\n' + result.content
def channel(self): ssl_channel = implementations.ssl_channel_credentials(None, None, None) creds = get_credentials().create_scoped([SPEECH_SCOPE]) auth_header = ('Authorization', 'Bearer ' + creds.get_access_token().access_token) auth_plugin = implementations.metadata_call_credentials( lambda _, cb: cb([auth_header], None), name='google_creds') composite_channel = implementations.composite_channel_credentials( ssl_channel, auth_plugin) return implementations.secure_channel(SPEECH_API_HOST, SPEECH_API_PORT, composite_channel)
def run(host, port): _TIMEOUT_SECONDS = 1 cc = ssl_credentials = grpc.ssl_channel_credentials( open('CA_crt.pem').read()) channel = implementations.secure_channel(host, port, cc) #channel = implementations.insecure_channel(host,port) stub = echo_pb2.beta_create_EchoServer_stub(channel) response = stub.SayHello( echo_pb2.EchoRequest(firstname='john', lastname='doe'), _TIMEOUT_SECONDS) print response
def dial(self): if self.stub: self.stub.close() p = urlparse('http://' + self.addr) if self.root_certificates or self.private_key or self.certificate_chain: creds = implementations.ssl_channel_credentials( self.root_certificates, self.private_key, self.certificate_chain) channel = implementations.secure_channel(p.hostname, p.port, creds) else: channel = implementations.insecure_channel(p.hostname, p.port) self.stub = vtgateservice_pb2.beta_create_Vitess_stub(channel)
def make_channel(host, port): """Creates an SSL channel with auth credentials from the environment.""" # In order to make an https call, use an ssl channel with defaults ssl_channel = implementations.ssl_channel_credentials(None, None, None) # Grab application default credentials from the environment creds = get_credentials().create_scoped([SPEECH_SCOPE]) # Add a plugin to inject the creds into the header auth_header = ("Authorization", "Bearer " + creds.get_access_token().access_token) auth_plugin = implementations.metadata_call_credentials(lambda _, cb: cb([auth_header], None), name="google_creds") # compose the two together for both ssl and google auth composite_channel = implementations.composite_channel_credentials(ssl_channel, auth_plugin) return implementations.secure_channel(host, port, composite_channel)
def EstablishChannel(address, port, client_id, user, password): # Open a grpc channel to the device creds = implementations.ssl_channel_credentials(open('/tmp/host.pem').read(), None, None) channel = implementations.secure_channel(address, port, creds) # Create stub for authentication login_stub = authentication_service_pb2.beta_create_Login_stub(channel) # Fill the login request message structure login_request = authentication_service_pb2.LoginRequest(user_name=user, password=password, client_id=client_id) # Invoke the login check API login_response = login_stub.LoginCheck(login_request, _TIMEOUT_SECONDS) print login_response return channel
def __init__(self, host, port, creds=None, channel_type="insecure_channel"): if channel_type == "insecure_channel": channel = implementations.insecure_channel(host, int(port)) elif channel_type == "secure_channel": channel = implementations.secure_channel(host, int(port), cred) else: print 'Invalid channel_type' exit(1) self._stub = prediction_service_pb2.beta_create_PredictionService_stub( channel)
def __init__(self, host, port, channel_credentials=None): """ :type host: str :param host: The name of the remote host to which to connect. :type port: int :param port: The port of the remote host to which to connect. """ if channel_credentials is None: # Create an `insecure_channel`. channel = implementations.insecure_channel(host, port) else: # Create a `secure_channel`. channel = implementations.secure_channel(host, port, channel_credentials) self._channel = channel self._stubs = []
def run(): # 连接 rpc 服务器 # TSL连接方式 >>> with open('G:\\DotNet\\SevenTiny.Cloud.FaaS\\Code\\Python\\SevenTiny.Cloud.FaaS.GRpc\\ca\\client.pem', 'rb') as f: pem = f.read() creds = implementations.ssl_channel_credentials( pem, None, None) channel = implementations.secure_channel('localhost', 5001, creds) # TSL连接方式 <<< # channel = grpc.insecure_channel('localhost:39901') # 调用 rpc 服务 stub = helloworld_pb2_grpc.GreeterStub(channel) response = stub.SayHello(helloworld_pb2.HelloRequest(name='czl')) print("Greeter client received: " + response.message) response = stub.SayHelloAgain(helloworld_pb2.HelloRequest(name='daydaygo')) print("Greeter client received: " + response.message)
def EstablishChannel(address, port, client_id, user, password): # Open a grpc channel to the device creds = implementations.ssl_channel_credentials( open('/tmp/host.pem').read(), None, None) channel = implementations.secure_channel(address, port, creds) # Create stub for authentication login_stub = authentication_service_pb2.beta_create_Login_stub(channel) # Fill the login request message structure login_request = authentication_service_pb2.LoginRequest( user_name=user, password=password, client_id=client_id) # Invoke the login check API login_response = login_stub.LoginCheck(login_request, _TIMEOUT_SECONDS) print login_response return channel
def make_channel(host, port): """Creates an SSL channel with auth credentials from the environment.""" # In order to make an https call, use an ssl channel with defaults ssl_channel = implementations.ssl_channel_credentials(None, None, None) # Grab application default credentials from the environment creds = get_credentials().create_scoped([SPEECH_SCOPE]) # Add a plugin to inject the creds into the header auth_header = ('Authorization', 'Bearer ' + creds.get_access_token().access_token) auth_plugin = implementations.metadata_call_credentials( lambda _, cb: cb([auth_header], None), name='google_creds') # compose the two together for both ssl and google auth composite_channel = implementations.composite_channel_credentials( ssl_channel, auth_plugin) return implementations.secure_channel(host, port, composite_channel)
def main(): deployment_url = DEPLOYMENT_URL deployment_url += "/api/v2/modelServers" token = globals.request.headers.get("Authorization") headers = {'Authorization': token, 'Cache-Control': "no-cache"} querystring = {"modelName": MODEL_NAME, "modelVersion": MODEL_VERSION} response = requests.request("GET", deployment_url, headers=headers, params=querystring) model_info = json.loads(response.text) model_info = model_info["modelServers"][0] endpoint = model_info["endpoints"][0] credentials = implementations.ssl_channel_credentials( root_certificates=str(endpoint["caCrt"])) channel = implementations.secure_channel(str(endpoint["host"]), int(endpoint["port"]), credentials) stub = prediction_service_pb2.beta_create_PredictionService_stub( channel, metadata_transformer=metadata_transformer) data_str = globals.request.get_data().split(",") data = [] for idx in range(len(data_str)): data.append(float(data_str[idx])) request = predict_pb2.PredictRequest() request.model_spec.name = MODEL_NAME request.model_spec.signature_name = 'serving_default' tfutil = tf.contrib.util t_proto = tfutil.make_tensor_proto(data, shape=[1, len(data)], dtype="float") request.inputs["input_image"].CopyFrom(t_proto) predict = stub.Predict(request, 1500) print predict res = predict.outputs['dense_2/Sigmoid:0'].float_val[0] print res return str(res)
def google_grpc_channel(self, host, port): """Creates an SSL channel with auth credentials from the environment.""" # In order to make an https call, use an ssl channel with defaults ssl_channel = implementations.ssl_channel_credentials(None, None, None) # Grab application default credentials from the environment creds = GoogleCredentials.from_stream(os.path.join(app_dir,"audio_creds.json")).create_scoped([SPEECH_SCOPE]) # Add a plugin to inject the creds into the header auth_header = ( 'Authorization', 'Bearer ' + creds.get_access_token().access_token) auth_plugin = implementations.metadata_call_credentials( lambda _, cb: cb([auth_header], None), name='google_creds') # compose the two together for both ssl and google auth composite_channel = implementations.composite_channel_credentials( ssl_channel, auth_plugin) return implementations.secure_channel(host, port, composite_channel)
def main(): credentials = implementations.ssl_channel_credentials( root_certificates=ROOT_CERT) channel = implementations.secure_channel(MODEL_SERVER_HOST, MODEL_SERVER_PORT, credentials) stub = prediction_service_pb2.beta_create_PredictionService_stub( channel, metadata_transformer=metadata_transformer) # process the first file only uploaded_files = globals.request.files.getlist('file') data = uploaded_files[0].read() # See prediction_service.proto for gRPC request/response details. # change input type and data shapes according to your model request = predict_pb2.PredictRequest() request.model_spec.name = MODEL_NAME request.model_spec.signature_name = 'predict_images' request.inputs['images'].CopyFrom( tf.contrib.util.make_tensor_proto(data, shape=[1])) return str(stub.Predict(request, 120))
def init(self): if not self._initialized: if self._config['root_certificates'] != '': self._creds = implementations.ssl_channel_credentials( utils.resource_string(self._config['root_certificates']), None, None) self._channels = {} self._stubs = {} for label, server in self._servers.items(): if server['ssl']: chan = implementations.secure_channel( server['host'], server['port'], self._creds) else: chan = implementations.insecure_channel( server['host'], server['port']) st = message_pb2.beta_create_Communication_stub(chan) self._channels[label] = chan self._stubs[label] = st self._initialized = True
def create_stub(generated_create_stub, service_path, port, ssl_creds=None, channel=None, metadata_transformer=None, scopes=None): """Creates a gRPC client stub. Args: generated_create_stub: The generated gRPC method to create a stub. service_path: The domain name of the API remote host. port: The port on which to connect to the remote host. ssl_creds: A ClientCredentials object for use with an SSL-enabled Channel. If none, credentials are pulled from a default location. channel: A Channel object through which to make calls. If none, a secure channel is constructed. metadata_transformer: A function that transforms the metadata for requests, e.g., to give OAuth credentials. scopes: The OAuth scopes for this service. This parameter is ignored if a custom metadata_transformer is supplied. Returns: A gRPC client stub. """ if channel is None: if ssl_creds is None: ssl_creds = implementations.ssl_channel_credentials( None, None, None) if metadata_transformer is None: if scopes is None: scopes = [] metadata_transformer = auth.make_auth_func(scopes) channel_creds = _make_channel_creds(metadata_transformer, ssl_creds) channel = implementations.secure_channel(service_path, port, channel_creds) return generated_create_stub(channel)
def __init__(self, host, port, channel_credentials=None): if channel_credentials is None: # Instantiate insecure channel object. channel = implementations.insecure_channel(host, port) else: # Instantiate secure channel object. channel = implementations.secure_channel(host, port, channel_credentials) self._stubs = ( # 0 sl_route_ipv4_pb2.beta_create_SLRoutev4Oper_stub(channel), # 1 sl_route_ipv6_pb2.beta_create_SLRoutev6Oper_stub(channel), # 2 sl_global_pb2.beta_create_SLGlobal_stub(channel), # 3 sl_mpls_pb2.beta_create_SLMplsOper_stub(channel), # 4 sl_bfd_ipv4_pb2.beta_create_SLBfdv4Oper_stub(channel), # 5 sl_bfd_ipv6_pb2.beta_create_SLBfdv6Oper_stub(channel), # 6 sl_interface_pb2.beta_create_SLInterfaceOper_stub(channel), )
from grpc.beta import implementations from gen import query_pb2 from os import path _TIMEOUT_SECONDS = 30 DIR=path.dirname(path.dirname(path.abspath(__file__))) creds = implementations.ssl_channel_credentials( open(path.join(DIR, "ssl/domain.crt")).read(), None, None ) channel = implementations.secure_channel('localhost', 50051, creds) stub = query_pb2.beta_create_SearchService_stub(channel) search_request = query_pb2.SearchRequest() search_request.query = "search" search_request.page_number = 1 search_request.result_per_page = 30 print(stub.Search(search_request, _TIMEOUT_SECONDS)) hello_request = query_pb2.HelloRequest() hello_request.name = "python" print(stub.SayHello(hello_request, _TIMEOUT_SECONDS))
def main(): deployment_url = "https://mlftrial-deployment-api.cfapps.eu10.hana.ondemand.com" + "/api/v2/modelServers" querystring = {"modelName": MODEL_NAME} headers = { 'Authorization': get_access_token(), 'Cache-Control': "no-cache" } response = requests.request("GET", deployment_url, headers=headers, params=querystring) #print(response.text) model_info = json.loads(response.text) latest_version = [0, 0] for index, model in enumerate(model_info["modelServers"]): if int(model["specs"]["models"][0] ["modelVersion"]) > latest_version[0]: latest_version = [ int(model["specs"]["models"][0]["modelVersion"]), index ] model_host = model_info["modelServers"][latest_version[1]]["endpoints"][0] credentials = implementations.ssl_channel_credentials( root_certificates=str(model_host["caCrt"])) channel = implementations.secure_channel(str(model_host["host"]), int(model_host["port"]), credentials) stub = prediction_service_pb2.beta_create_PredictionService_stub( channel) #, metadata_transformer=metadata_transformer) #uploaded_files = globals.request.files.getlist('file') #data = skimage.io.imread(uploaded_files[0]) feature_dict = { 'DIFGRIRV': tf.train.Feature(int64_list=tf.train.Int64List(value=[-38100])), 'NODLIR': tf.train.Feature(int64_list=tf.train.Int64List(value=[90])), 'VSTATU': tf.train.Feature(bytes_list=tf.train.BytesList(value=[b"1"])), 'NODLGR': tf.train.Feature(int64_list=tf.train.Int64List(value=[0])), 'DIFGRIRD': tf.train.Feature(int64_list=tf.train.Int64List(value=[-80])), 'VPATD': tf.train.Feature(int64_list=tf.train.Int64List(value=[30])), 'WERKS': tf.train.Feature(bytes_list=tf.train.BytesList(value=[b"ML01"])), 'EKORG': tf.train.Feature(bytes_list=tf.train.BytesList(value=[b"1"])), 'TOTGRQTY': tf.train.Feature(int64_list=tf.train.Int64List(value=[0])), 'SCENARIO': tf.train.Feature(bytes_list=tf.train.BytesList(value=[b"3"])), 'TOTIRQTY': tf.train.Feature(int64_list=tf.train.Int64List(value=[80])), 'KTOKK': tf.train.Feature(bytes_list=tf.train.BytesList(value=[b"1"])), 'EKGRP': tf.train.Feature(bytes_list=tf.train.BytesList(value=[b"A"])), } example = tf.train.Example(features=tf.train.Features( feature=feature_dict)) data = example.SerializeToString() # data = {"DIFGRIRV": [-38100],"NODLIR": [90],"VSTATU": ["1"],"NODLGR": [0],"DIFGRIRD": [-80],"VPATD": [30], # "WERKS": ["ML01"], # "EKORG": ["1"],"TOTGRQTY": [0],"SCENARIO": ["3"],"TOTIRQTY": [80],"KTOKK": ["1"],"EKGRP": ["A"]} req = predict_pb2.PredictRequest() req.model_spec.name = MODEL_NAME #req.model_spec.signature_name = 'predict_images' req.inputs["inputs"].CopyFrom( tf.contrib.util.make_tensor_proto(data, shape=[1, 1])) res = str(stub.Predict(req, 150)) # res = str(stub.Predict(req, 150)).split('}')[3].split('\n') print(res) res.pop(11) res.pop(0) out_val = 0.0 out = 0 for i, estimate in enumerate(res): if float(estimate[14:]) > out_val: out_val = float(estimate[14:]) out = i return "Result: " + str(out)
def secure_channel(): with open(FLAGS.certificate) as f: trusted_certs = f.read() credentials = implementations.ssl_channel_credentials( trusted_certs, None, None) return implementations.secure_channel(FLAGS.address, FLAGS.port, credentials)
def create_pubsub_stub(host=PUBSUB_ENDPOINT, port=SSL_PORT): """Creates a secure pubsub channel.""" ssl_creds = implementations.ssl_channel_credentials(None, None, None) channel_creds = make_channel_creds(ssl_creds, auth_func) channel = implementations.secure_channel(host, port, channel_creds) return pubsub_pb2.beta_create_Publisher_stub(channel)
def create_sub_stub(host=PUBSUB_ENDPOINT, port=SSL_PORT): """Creates a secure pubsub channel.""" ssl_creds = implementations.ssl_channel_credentials(None, None, None) channel_creds = make_channel_creds(ssl_creds, auth_func) channel = implementations.secure_channel(host, port, channel_creds) return pubsub_pb2.beta_create_Subscriber_stub(channel)