def __init__(self, send_handler, frequency): self.log = getLogger(self.__class__.__name__) self.send = send_handler # Controls shared object self.controls = Controls() # Commands uplink queue self.commands = Queue() # Uplink services uplink generated packets at certain frequency self.uplink_services = ServiceManager([ Service('Controls', self.send, self.controls, frequency, 1), Service('Commands', self.command_handler, self.commands, frequency, 2), ]) self.user_input = UserInput(self.controls, self.commands) self.user_input.non_flight() def signal_handler(sig_num, frame): self.log.info('Shutting down') self.uplink_services.stop('Controls') self.uplink_services.stop('Commands') self.user_input.stop(True) sys.exit(0) signal.signal(signal.SIGINT, signal_handler) self.uplink_services.start('Commands') self.uplink_services.start('Controls') self.user_input.run()
def onnet_CCM_Y1564_CCA(A, B): print("!" * 1) print("!" * 2) print("************** Test {}{} type EP ************* ".format(A, B)) print("!!" * 3) dict1 = yaml.load(open(file_path + '/../Topology/inputfile_CCUA.yml'), Loader=yaml.Loader) dict1['site_list'][0]['port_type'] = '{}-type'.format(A) dict1['site_list'][1]['port_type'] = '{}-type'.format(B) dict1['site_list'][2]['port_type'] = '{}-type'.format(B) my_config = Service(**dict1) my_config.connect_OLO_nodes() my_config.create_commands_OLO() my_config.push_OLO_config() my_config.connect_nodes() my_config.parse_accedian() my_config = Service(**dict1) my_config.Command_Creation() my_config.push_config() time.sleep(10) test_result = {} test_result['ccm_status'] = my_config.Validate_ccm() #test_result['Loop_test'] = my_config.Y1564_test() #my_config.check_QOS_counters_config() #test_result['CFM_Stats_Acc'] = my_config.mep_statistic_accedian() #test_result['CFM_Stats_cisco'] = my_config.mep_statistic_cisco() my_config.delete_config() my_config.disconnect_nodes() my_config.delete_OLO_config() my_config.disconnect_OLO_nodes() return test_result
def __init__(self): parser = ConfigParser() parser.read("files/settings.properties") self.ui = None if parser.get("options", "ui") == "console": self.ui = UI elif parser.get("options", "ui") == "gui": self.ui = GUI repo_style = parser.get("options", "repository") if repo_style == "memory": self.ui = self.ui(Service()) elif repo_style == "json": self.ui = self.ui( Service( StudentRepoJson(parser.get("options", "students")), DisciplineRepoJson(parser.get("options", "disciplines")), GradesRepoJson(parser.get("options", "grades")))) elif repo_style == "binary": self.ui = self.ui( Service( StudentRepoBinary(parser.get("options", "students")), DisciplineRepoBinary(parser.get("options", "disciplines")), GradesRepoBinary(parser.get("options", "grades")))) elif repo_style == "csv": self.ui = self.ui( Service( StudentRepoCSV(parser.get("options", "students")), DisciplineRepoCSV(parser.get("options", "disciplines")), GradesRepoCSV(parser.get("options", "grades")))) elif repo_style == "database": self.ui = self.ui( Service( StudentRepoDatabase(parser.get("options", "database")), DisciplineRepoDatabase(parser.get("options", "database")), GradesRepoDatabase(parser.get("options", "database"))))
def test_divide(self, mock_service): mock_service.return_value = 12 # call the divide fun, iton in service assert Service().divide(2) == 6 assert Service().divide(4) == 3 assert Service().divide(-2) == -6 assert Service().divide(12) == 1 return
def test_divide(self, mock_service): mock_service.return_value = 18 assert Service().divide(2) == 9 with pytest.raises(ZeroDivisionError): Service().divide(0) assert Service().divide(-18) == -1 assert Service().divide(-2) == -9 return
def get(): print('Get User - Controller') try: user_id = request.args['userId'] service = Service() response = service.get_user(user_id=int(user_id)) except: service = Service() response = service.get_all_users() # print('type of response - ', type(response)) return response
def test_abs_plus(self): x = Service() self.assertEqual(x.abs_plus(10), 11) self.assertEqual(x.abs_plus(0), 1) self.assertEqual(x.abs_plus(-10), 11) self.assertEqual(x.abs_plus(-sys.maxsize + 1), sys.maxsize) self.assertEqual(x.abs_plus(10), 11)
def save_message(): try: svc = Service() svc_response = svc.save_message(request.data) return SvcUtils.handle_response(svc_response, status.HTTP_201_CREATED) except Exception as ex: return SvcError.handle_error(ex)
def __init__(self, executable_path='IEDriverServer.exe', port=DEFAULT_PORT, timeout=DEFAULT_TIMEOUT, host=DEFAULT_HOST, log_level=DEFAULT_LOG_LEVEL, log_file=DEFAULT_LOG_FILE): self.port = port if self.port == 0: self.port = utils.free_port() self.host = host self.log_level = log_level self.log_file = log_file self.iedriver = Service(executable_path, port=self.port, host=self.host, log_level=self.log_level, log_file=self.log_file) self.iedriver.start() RemoteWebDriver.__init__( self, command_executor='http://localhost:%d' % self.port, desired_capabilities=DesiredCapabilities.INTERNETEXPLORER) self._is_remote = False
def __init__(self, connection, login, initList): Thread.__init__(self) self.c = connection self.d = Service(self.c) self.d.registration(login) self.id = self.d.login(login) self.l = initList
def test_bad_random(self): mockService = Service() #test case good data mockData = "1\n2\n3\n4\n5\n6\n7\n8\n9\n10" with patch('service.open', mock_open(read_data=mockData)): mockService.bad_random = mock.Mock(return_value=5) badNumber = Service.bad_random() fileLines = mockData.count('\n') + 1 self.assertTrue(0 <= badNumber <= fileLines) #test case file not found self.assertRaises(FileNotFoundError, Service.bad_random) #test case empty file mockData = "" with patch('service.open', mock_open(read_data=mockData)): fileLines = mockData.count('\n') + 1 self.assertTrue(fileLines == 1) self.assertRaises(FileNotFoundError, Service.bad_random) #test case not a number mockData = "A\nB\nC\nD\nE" with patch('service.open', mock_open(read_data=mockData)): fileLines = mockData.count('\n') + 1 self.assertTrue(fileLines == 5) self.assertRaises(FileNotFoundError, Service.bad_random)
def test_complicated_function(divide, bad_random): service = Service() bad_random.return_value = 8 divide.return_value = 4 assert service.complicated_function(2)[0] == 4 assert service.complicated_function(2)[1] == 0 bad_random.return_value = 0 divide.return_value = 0 assert service.complicated_function(2)[0] == 0 assert service.complicated_function(2)[1] == 0 bad_random.return_value = -4 divide.return_value = -2 assert service.complicated_function(2)[0] == -2 assert service.complicated_function(2)[1] == 0 bad_random.return_value = 5 divide.return_value = 1 assert service.complicated_function(5)[0] == 1 assert service.complicated_function(5)[1] == 1
def parse_service_data(data): """Create a map of service objects from the weird JSON we get from the console.""" services = defaultdict() for service_url, service_details in data["services"]["_embedded"].items(): service = Service(service_url, service_details) services[service.service_name] = service return services
def __init__(self, executable_path="chromedriver", port=0, desired_capabilities=None, chrome_options=None): """ Creates a new instance of the chrome driver. Starts the service and then creates new instance of chrome driver. :Args: - executable_path - path to the executable. If the default is used it assumes the executable is in the $PATH - port - port you would like the service to run, if left as 0, a free port will be found. - desired_capabilities: Dictionary object with desired capabilities (Can be used to provide various chrome switches). This is being deprecated, please use chrome_options - chrome_options: this takes an instance of ChromeOptions """ if chrome_options is None: options = Options() else: options = chrome_options if desired_capabilities is not None: warnings.warn("Desired Capabilities has been deprecated, please user chrome_options.", DeprecationWarning) desired_capabilities.update(options.to_capabilities()) else: desired_capabilities = options.to_capabilities() self.service = Service(executable_path, port=port) self.service.start() try: RemoteWebDriver.__init__(self, command_executor=self.service.service_url, desired_capabilities=desired_capabilities) except: self.quit() raise WebDriverException("The Driver was not able to start.")
def test_NewLandTrade_LandSold_CorrectAmount(self): my_validation=Validation() my_service=Service(my_validation) my_service.set_acres_owned(1) my_service.set_acres_trade(-1) my_service.new_land_trade() self.assertEqual(my_service.get_acres_owned(), 0)
def test_GrainstocksAfterRatInfestation_RatInfestation_NewGrainstocks(self): my_validation=Validation() my_service=Service(my_validation) previous_grainstock=my_service.get_grain_stocks() my_service.set_rats_ate(100) my_service.grainstocks_after_rat_infestation() self.assertLess(my_service.get_grain_stocks(), previous_grainstock)
def test(self): expected = dict( prefix="sqs", description="For Queues and Stuffs", arn_format="arn:blah:blah:blah", arn_regex="arn:.+:.+:.+", docs=dict( actions_doc_root="", authz_doc_page="", concepts_doc_root="", context_keys_doc_root="", api_detail_root="", api_doc_root="", api_reference_doc_page="", ), actions=dict(PurgeQueue=dict( description="Remove all entries from Queue", aws_action_groups=["ReadWrite"], calculated_action_group="Write", condition_keys=["a4b:amazonId"], docs=dict(api_doc="", doc_page_rel="", doc_page=""), )), ) expected = json.dumps(expected, sort_keys=True, indent=2) # Create Service and Service Action my_service = Service(self.url, self.aws_response) my_service_action = ServiceAction(my_service, self.body) # Associate the two my_service.actions[my_service_action.action_name] = my_service_action response = json.dumps(my_service.toJSON(), sort_keys=True, indent=2) assert expected == response
def test_abs_plus(): newService = Service() assert newService.abs_plus(-10) == (abs(-10) + 1) assert newService.abs_plus(10) == (abs(10) + 1) assert newService.abs_plus(0) == (abs(0) + 1) assert newService.abs_plus(3.14) == (abs(3.14) + 1)
def get_service_list(self): """Gets a list of Service objects in this TsItem Searches through the TsItem descriptors for descriptors of type ServiceListDescriptor and ChannelListMappingDescriptor. The information from both of these descriptors is used to build a dictionary objects keyed by service triplet. Returns: A dictionary of Service objects keyed by service triplet or None """ svl_types = {} svl_channels = {} svl = {} for desc in self.descriptors: if type(desc) == descriptors.ServiceListDescriptor: svl_types = desc.services if type(desc) == descriptors.ChannelListMappingDescriptor: svl_channels = desc.service_channel_map if len(svl_types) > 0: svl_iterator = svl_types elif len(svl_channels) > 0: svl_iterator = svl_channels else: return None#TODO - should select the longest list to iterate with for service_id in svl_iterator: ts_id = self.transport_stream_id n_id = self.original_network_id channel = None stpe = None if service_id in svl_channels: channel = svl_channels[service_id] if service_id in svl_types: stpe = svl_types[service_id] svc = Service(nid=n_id, tsid=ts_id, svid=service_id, chan=channel, type=stpe) svl[(n_id, ts_id, service_id)] = svc return svl
def test_complicated_function(divide, bad_random): newService = Service() bad_random.return_value = 6 divide.return_value = 3 assert newService.complicated_function(2)[0] == 3 assert newService.complicated_function(2)[1] == 6 % 2 bad_random.return_value = 6 divide.return_value = -3 assert newService.complicated_function(-2)[0] == -3 assert newService.complicated_function(-2)[1] == 6 % -2 divide.return_value = 0 bad_random.return_value = 0 assert newService.complicated_function(6)[0] == 0 assert newService.complicated_function(6)[1] == 0 divide.return_value = None bad_random.return_value = 4 try: newService.complicated_function(0) except ZeroDivisionError: assert True divide.return_value = 2 assert newService.complicated_function(2)[0] == 2 assert newService.complicated_function(2)[0] == 0
def test_divide(self): mockService = Service() #test case divisor is zero mockService.bad_random = mock.Mock(return_value=4) self.assertRaises(ZeroDivisionError, mockService.divide, 0) #test case dividend is zero mockService.bad_random = mock.Mock(return_value=0) quotient = mockService.divide(4) self.assertTrue(quotient == 0) #test case dividend and divisor both same non zero value mockService.bad_random = mock.Mock(return_value=7) quotient = mockService.divide(7) self.assertTrue(quotient == 1) #test case non zero dividend and divisor different non zero value mockService.bad_random = mock.Mock(return_value=6) quotient = mockService.divide(3) self.assertTrue(quotient == 2) #test case non zero dividend and divisor not a number mockService.bad_random = mock.Mock(return_value=9) self.assertRaises(TypeError, mockService.divide, 'string')
def execCreateContainer(request): print "start execCreateContainer()" if request.method=="GET": dictCon={} rqmc=request.GET.get("rqmc") dictCon["rqmc"]=rqmc rqzjm=request.GET.get("rqzjm") dictCon["rqzjm"]=rqzjm wlpz=request.GET.get("wlpz") dictCon["wlpz"]=wlpz srsclx=request.GET.get("srsclx") dictCon["srsclx"]=srsclx rqdnsfwq=request.GET.get("rqdnsfwq") dictCon["rqdnsfwq"]=rqdnsfwq rqdnsssym=request.GET.get("rqdnsssym") dictCon["rqdnsssym"]=rqdnsssym szjdk=request.GET.get("szjdk") dictCon["szjdk"]=szjdk rqdk=request.GET.get("rqdk") dictCon["rqdk"]=rqdk jxm=request.GET.get("jxm") dictCon["jxm"]=jxm s=Service() stdmsg=s.createContainer(dictCon) #print "stdmsg="+stdmsg return HttpResponse(json.dumps({"rst":stdmsg}))
def mainstart(self): bucle = True while bucle: try: option = int(input("Digita la opción que desees ejecutar: ")) print() if option == 1: Clients().start() self.menu() elif option == 2: Vehicles().start() self.menu() elif option == 3: Service().start() self.menu() elif option == 4: Facturas().get_all() self.menu() elif option == 5: Facturas().hola() self.menu() elif option == 6: self.menu() elif option == 7: bucle = False print() except NameError: print(NameError) print("7. Mostrar menú de modulos [7]") print( "La opción digitada es invalida (debe ser un número en el menú)." ) print()
def execInputCommand(request): print "start execInputCommand" if request.method=="GET": cmd=request.GET.get("srzl") s=Service() stdmsg=s.execInputCommand(cmd) return HttpResponse(json.dumps({"rst":stdmsg}))
def ping(): try: svc = Service() svc_response = svc.ping() return SvcUtils.handle_response(svc_response, status.HTTP_200_OK) except Exception as ex: return SvcError.handle_error(ex)
def test_abs_plus(): serviceTest = Service() testValue = serviceTest.abs_plus(-5) assert (testValue == 6) testValue = serviceTest.abs_plus(0) assert (testValue == 1)
def get_message_by_username(username): try: svc = Service() svc_response = svc.get_message_by_username(username) return SvcUtils.handle_response(svc_response, status.HTTP_200_OK) except Exception as ex: return SvcError.handle_error(ex)
def StartServices(self): # check the state of the cluster if self.state == "down": return images = self.GetImages() self.services = {} # key:image name, value: image # build service structure for image in images: status = "" status = raw_input("Do you want to start " + image.repo + " [y/n]: ").lower() if (status == 'y' or status == 'yes'): status = 'RUN' else: status = 'STOP' self.services[image.repo] = Service(image, 1, status, 3000, 3000) # start services # could use threads here to go through and start them all, asssuming # docker is cool with that... for key in self.services: if self.services[key].state == "RUN": #execute the run command print('Starting service: {0}'.format(key)) self.services[key].start() elif self.services[key].state == 'STOP': print('Stopping service: {0}'.format(key)) self.services[key].stop()
def start(msg=None): # rospy.init_node('we_python_sm', None, False, 2, False, False, True) rospy.init_node('we_python_sm', log_level=rospy.DEBUG, anonymous=True) brain = DNGetMsg() if msg == None or len(msg) > 3 or len(msg) == 1: stateMachineThread = StateMachine() elif len(msg) == 2: # msg[1] is name of subroutine stateMachineThread = StateMachine(msg[1]) else: # msg[2] is the string argv of the subroutine specified by msg[1] stateMachineThread = StateMachine(msg[1], eval(msg[2])) stateMachineThread.start() serviceThread = Service() serviceThread.start() rospy.spin() serviceThread.stop() stateMachineThread.stop() serviceThread.join() stateMachineThread.join()
def addService(self, sDate, iDate, mNum, pNum, code, name, fee): """Adds a service to the appropriate member and provider.""" print('Adding service with' + ' \nService date: ' + sDate + ' \nInput date: ' + iDate + ' \nMember Number: ' + mNum + ' \nProvider Number: ' + pNum + ' \nCode: ' + str(code) + ', Name: ' + str(name) + ', Fee: ' + str(fee)) mem = self.getMember(mNum) prov = self.getProvider(pNum) if mem is None: deb.warn('Member number was none.') if prov is None: deb.warn('Provider number was none.') service = Service(sDate, iDate, mem, prov, code, name, fee) for member in self.members: if member.number == mNum: member.services.append(service) for provider in self.providers: if provider.number == pNum: provider.services.append(service)