def _raise_if_not_200(self, status_code, response_body): # response_body here is str in Py3 if status_code != self.HTTP_SC_200: expected_exception = self._expected_exception_map.get(status_code) if expected_exception: raise expected_exception else: raise DiscoveryFailure(response_body) return DiscoveryInfo(response_body)
def ggc_discovery(thing_name, discovery_info_provider, retry_count=10, max_groups=1): back_off_core = ProgressiveBackOffCore() discovered = False discovery_info = None while retry_count != 0: try: discovery_info = discovery_info_provider.discover(thing_name) group_list = discovery_info.getAllGroups() if len(group_list) > max_groups: raise DiscoveryFailure("Discovered more groups than expected") discovered = True break except DiscoveryFailure as df: logging.error( "Discovery failed! Error:{0} type:{1} message:{2}".format( df, str(type(df)), df.message)) back_off = True except DiscoveryInvalidRequestException as e: logging.error("Invalid discovery request! Error:{0}".format(e)) logging.error("Stopping discovery...") break except BaseException as e: logging.error( "Error in discovery:{0} type:{1} message:{2} thing_name:{3} " "dip:{4}".format(e, str(type(e)), e.message, thing_name, discovery_info_provider)) back_off = True if back_off: retry_count -= 1 logging.info("{0} retries left\n".format(retry_count)) logging.debug("Backing off...\n") back_off_core.backOff() return discovered, discovery_info
def discover(host, rootCAPath, certificatePath, privateKeyPath, thingName, devicePath): # Progressive back off core backOffCore = ProgressiveBackOffCore() # Discover GGCs discoveryInfoProvider = DiscoveryInfoProvider() discoveryInfoProvider.configureEndpoint(host) discoveryInfoProvider.configureCredentials(rootCAPath, certificatePath, privateKeyPath) discoveryInfoProvider.configureTimeout(10) # 10 sec print("Iot end point: {}".format(host)) print("Iot CA Path: {}".format(rootCAPath)) print("GGAD cert path: {}".format(certificatePath)) print("GGAD private key path: {}".format(privateKeyPath)) print("GGAD thing name : {}".format(thingName)) retryCount = MAX_DISCOVERY_RETRIES discovered = False groupCA = None coreInfo = None while retryCount != 0: try: discoveryInfo = discoveryInfoProvider.discover(thingName) groupList = discoveryInfo.getAllGroups() if len(groupList) > 1: raise DiscoveryFailure("Discovered more groups than expected") caList = discoveryInfo.getAllCas() coreList = discoveryInfo.getAllCores() # We only pick the first ca and core info groupId, ca = caList[0] coreInfo = coreList[0] print("Discovered GGC: %s from Group: %s" % (coreInfo.coreThingArn, groupId)) hostAddr = "" # In this example Ip detector lambda is turned on which reports # the GGC hostAddr to the CIS (Connectivity Information Service) that stores the # connectivity information for the AWS Greengrass core associated with your group. # This is the information used by discovery and the list of host addresses # could be outdated or wrong and you would normally want to # validate it in a better way. # For simplicity, we will assume the first host address that looks like an ip # is the right one to connect to GGC. # Note: this can also be set manually via the update-connectivity-info CLI connList = coreInfo.connectivityInfoList print connList for addr in connList: hostAddr = addr.host if isIpAddress(hostAddr): print('Check: {}'.format(hostAddr)) print("Discovered GGC Host Address: " + hostAddr) print("Now we persist the connectivity/identity information...") groupCA = '{}/{}'.format(devicePath, GROUP_CA_PATH + CA_NAME) ggcHostPath = '{}/{}'.format(devicePath, GROUP_CA_PATH + GGC_ADDR_NAME) if not os.path.exists('{}/{}'.format(devicePath, GROUP_CA_PATH)): os.makedirs('{}/{}'.format(devicePath, GROUP_CA_PATH)) groupCAFile = open(groupCA, "w") groupCAFile.write(ca) groupCAFile.close() groupHostFile = open(ggcHostPath, "w") groupHostFile.write(hostAddr) groupHostFile.close() discovered = True print("Now proceed to the connecting flow...") break except DiscoveryInvalidRequestException as e: print("Invalid discovery request detected!") print("Type: " + str(type(e))) print("Error message: " + e.message) print("Stopping...") break except BaseException as e: print("Error in discovery!") print("Type: " + str(type(e))) print("Error message: " + e.message) retryCount -= 1 print("\n" + str(retryCount) + "/" + str(MAX_DISCOVERY_RETRIES) + " retries left\n") print("Backing off...\n") backOffCore.backOff() else: if not discovered: print("Discovery failed after %d retries. Exiting...\n" % (MAX_DISCOVERY_RETRIES)) sys.exit(-1)