| #!/usr/bin/env python |
| |
| |
| # |
| # Copyright (c) 2015-2017 Nest Labs, Inc. |
| # All rights reserved. |
| # |
| # 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. |
| # |
| |
| # |
| # @file |
| # Implements generate register service cmd which is used to service provisioning |
| |
| import json |
| import os |
| import requests |
| import shutil |
| import sys |
| import tarfile |
| |
| from grpc.beta import implementations |
| from grpc.framework.interfaces.face.face import ExpirationError |
| from httplib import HTTPSConnection |
| from happy.Driver import Driver |
| from happy.Utils import * |
| |
| options = {} |
| options["tier"] = None |
| options["username"] = None |
| options["password"] = None |
| |
| def option(): |
| return options.copy() |
| |
| |
| default_schema_branch = 'develop' |
| apigw_fmt = 'apigw01.weave01.iad02.{tier}.nestlabs.com' |
| phoenix_mirror_url = 'http://device-automation.nestlabs.com/phoenix-schema/python' |
| |
| python_local = os.path.expanduser('~/.python-local') |
| phoenix_cache = os.path.join(python_local, 'phoenix') |
| |
| |
| def get_phoenix_hash(branch): |
| url = '{}/{}/__latest__'.format(phoenix_mirror_url, branch) |
| response = requests.get(url) |
| response.raise_for_status() |
| return response.text.rstrip() |
| |
| _phoenix_proto_cache = dict() |
| |
| def get_phoenix_proto_dir(branch): |
| if branch in _phoenix_proto_cache: |
| return _phoenix_proto_cache.get(branch) |
| |
| latest_hash = get_phoenix_hash(branch) |
| tarball_dir = os.path.join(phoenix_cache, branch) |
| tarball_path = os.path.join(tarball_dir, '{}.tar.gz'.format(latest_hash)) |
| extract_dir = os.path.join(tarball_dir, latest_hash) |
| phoenix_dir = os.path.join(extract_dir, 'phoenix') |
| if not os.path.exists(extract_dir): |
| os.makedirs(extract_dir) |
| |
| if not os.path.exists(tarball_path): |
| url = '{}/{}/{}.tar.gz'.format(phoenix_mirror_url, branch, latest_hash) |
| response = requests.get(url, stream=True) |
| response.raise_for_status() |
| with open(tarball_path, 'wb') as tarball_file: |
| print type(response.raw) |
| shutil.copyfileobj(response.raw, tarball_file) |
| |
| if not os.path.exists(phoenix_dir): |
| with tarfile.open(tarball_path) as tar: |
| for member in tar.getmembers(): |
| if not member.isdir(): |
| tar.extract(member.path, path=extract_dir) |
| |
| _phoenix_proto_cache[branch] = phoenix_dir |
| return phoenix_dir |
| |
| def use_phoenix_schema(branch): |
| sys.path.insert(0, get_phoenix_proto_dir(branch)) |
| |
| class ServiceClient(object): |
| def __init__(self, tier, username, password, token, |
| schema_branch=default_schema_branch): |
| self.tier = tier |
| self.username = username |
| self.password = password |
| |
| use_phoenix_schema(schema_branch) |
| import nestlabs.gateway.v2.gateway_api_pb2 as gateway_api |
| self.gateway_api = gateway_api |
| auth_token = 'Basic ' + token |
| self._auth_metadata = [('authorization', auth_token)] |
| |
| def _create_gateway_service_stub(self): |
| apigw = apigw_fmt.format(tier=self.tier) |
| return \ |
| self.gateway_api.beta_create_GatewayService_stub( |
| implementations.insecure_channel(apigw, 9953)) |
| |
| @property |
| def account_id(self): |
| gateway_api = self.gateway_api |
| request = gateway_api.ObserveRequest() |
| request.state_types.append(gateway_api.StateType.Value('ACCEPTED')) |
| request.state_types.append(gateway_api.StateType.Value('CONFIRMED')) |
| |
| stub = self._create_gateway_service_stub() |
| for response in stub.Observe(request, 999999, self._auth_metadata): |
| for resource_meta in response.resource_metas: |
| if 'USER' in resource_meta.resource_id: |
| return resource_meta.resource_id.encode('utf-8') |
| if not response.initial_resource_metas_continue: |
| break |
| |
| @property |
| def structure_ids(self): |
| gateway_api = self.gateway_api |
| request = gateway_api.ObserveRequest() |
| request.state_types.append(gateway_api.StateType.Value('ACCEPTED')) |
| request.state_types.append(gateway_api.StateType.Value('CONFIRMED')) |
| |
| stub = self._create_gateway_service_stub() |
| |
| ids = [] |
| try: |
| for response in stub.Observe(request, 15, self._auth_metadata): |
| for resource_meta in response.resource_metas: |
| if 'STRUCTURE' in resource_meta.resource_id: |
| ids.append(resource_meta.resource_id.encode('utf-8')) |
| if not response.initial_resource_metas_continue: |
| break |
| except ExpirationError: |
| pass |
| finally: |
| return ids |
| |
| class WeaveRegisterService(Driver): |
| """ |
| weave-register-service [-h --help] [-q --quiet] [-t --tier <NAME>] [-u --username <NAME>] [-p --password <password>] |
| |
| --tier option is the service tier |
| |
| command to generate options of register-service cmd: |
| $ weave-register-serivce -t integration -u username@nestlabs.com -p yourpassword |
| |
| return: |
| options of the options of register service command |
| |
| """ |
| def __init__(self, opts = options): |
| Driver.__init__(self) |
| self.tier = opts["tier"] |
| self.username = opts["username"] |
| self.password = opts["password"] |
| self.headers = {'Content-Type' : 'application/json'} |
| |
| def __pre_check(self): |
| if not self.tier: |
| self.tier = "integration" |
| emsg = "WeaveRegisterService: Using default weave_service_tier %s." % (self.tier) |
| self.logger.debug(emsg) |
| |
| self.host = 'home.%s.nestlabs.com' % self.tier |
| |
| # Siac tiers contain 'unstable' and don't expose a 'home.*' hostname. |
| if 'unstable' in self.tier: |
| self.host = self.host.replace('home.','') |
| |
| if not self.username: |
| self.username = "test-it+pairing1@nestlabs.com" |
| emsg = "WeaveRegisterService: using default weave_service_username %s." % (self.username) |
| self.logger.debug(emsg) |
| |
| if not self.password: |
| # Check if service password is set |
| self.password = "nest-egg" |
| emsg = "WeaveRegisterService: using default weave_service_password %s." % (self.password) |
| self.logger.debug(emsg) |
| |
| self.params = json.dumps({'email': self.username, 'username': self.username, 'password':self.password}) |
| |
| self.access_token, self.user_id = self.get_cz_token_userid() |
| self.sessionJSON = self.__get_session_json() |
| client = ServiceClient(tier=self.tier, username=self.username, password=self.password, token=self.access_token) |
| self.structureids = client.structure_ids |
| self.accountid = client.account_id |
| self.initial_data = self.__get_initial_data_json() |
| |
| def get_cz_token_userid(self): |
| conn = HTTPSConnection(self.host) |
| path = '/api/0.2/create_user_login' |
| conn.request('POST', path, self.params, headers=self.headers) |
| login_response = conn.getresponse() |
| login_response_data = json.load(login_response) |
| if login_response.status == 201: |
| delayExecution(1) |
| self.logger.info("create account for user %s" % self.username) |
| token = login_response_data['access_token'] |
| user_id = login_response_data['user'] |
| else: |
| self.logger.info("get auth info for user %s" % self.username) |
| token, user_id = self.__get_account_auth() |
| return token, user_id |
| |
| |
| def __get_account_auth(self): |
| conn = HTTPSConnection(self.host) |
| path = '/api/0.1/authenticate_user' |
| conn.request('POST', path, self.params, headers=self.headers) |
| auth_response = conn.getresponse() |
| auth_response_data = json.load(auth_response) |
| if auth_response.status == 200: |
| self.logger.info("WeaveRegisterService: Authentication successful") |
| elif auth_response.status== 400: |
| emsg = "WeaveRegisterService: Unauthorized request for user authentication: status=%s error=%s" % ( |
| auth_response.status, auth_response.reason) |
| self.logger.info(emsg) |
| raise ValueError(emsg) |
| else: |
| # Not a 200 or 4xx auth error, server error. |
| emsg = "WeaveRegisterService: Service Error on user authentication: HTTPS %s: %s. " % ( |
| auth_response.status, auth_response.reason) |
| self.logger.info(emsg) |
| raise ValueError(emsg) |
| token = auth_response_data['access_token'] |
| user_id = auth_response_data['user'] |
| return token, user_id |
| |
| def __get_session_json(self): |
| conn = HTTPSConnection(self.host) |
| path = '/session' |
| conn.request('POST', path, self.params, headers=self.headers) |
| response = conn.getresponse() |
| data = response.read() |
| if response.status != 200 and response.status != 201: |
| emsg = 'WeaveRegisterService: Failed with status %d: %s. Password and login correct?' % (response.status, response.reason) |
| self.logger.info(emsg) |
| raise ValueError(emsg) |
| return json.loads(data) |
| |
| def __get_initial_data_json(self): |
| where_id = '00000000-0000-0000-0000-000100000010' |
| spoken_where_id = '00000000-0000-0000-0000-000100000010' |
| initialDataJSON = {'structure_id': self.structureids[0], 'where_id': where_id, 'spoken_where_id': spoken_where_id} |
| return initialDataJSON |
| |
| def run(self): |
| self.logger.debug("[localhost] WeaveRegisterService: Run.") |
| |
| self.__pre_check() |
| |
| self.cmd = ' --account-id %s --pairing-token %s --service-config %s --init-data \'%s\'' % (self.accountid, self.sessionJSON['weave']['pairing_token'], self.sessionJSON['weave']['service_config'], json.dumps(self.initial_data).encode("UTF-8")) |
| |
| print "weave-register-service generated the service registration command:" |
| |
| print hgreen("register-service %s : " % self.cmd) |
| |
| self.logger.debug("[localhost] WeaveRegisterService: Done.") |
| |
| return self.cmd |
