예제 #1
0
def restart(service):
    """Restarts the given service"""
    if service == 'all':
        return [Service(s).restart() for s in Service.SERVICE_LIST]
    service = Service(service)
    s.info(f"Restarting $[{service.name}]")
    service.restart()
예제 #2
0
    def test_main(self):
        manager = ServiceManager([
            Service('webserver', module_name='test_services_webserver'),
            Service('raspberry',
                    module_filename='./test_services_raspberry.py')
        ])
        manager_thread = threading.Thread(target=manager.serve)
        manager_thread.start()

        manager_thread.join()
예제 #3
0
def stop(service):
    """Stops any running service"""
    if service == 'all':
        s.info(
            f"Stopping all services: $[{', '.join(map(str, [s for s in Service.SERVICE_LIST]))}]\n"
        )
        return [Service(s).stop() for s in Service.SERVICE_LIST]
    service = Service(service)
    s.info(f"Stopping $[{service.name}]\n")
    service.stop()
예제 #4
0
def getExclusiveGroups(l, tl, prefixes):
    (qcl0, qcl1) = assignEndpoint2(tl, l, prefixes)
    views0 = []
    views1 = []
    for cl in qcl0:
        l0 = qcl0[cl]
        serv = Service(cl, l0)
        views0 = views0 + [serv]
    for t in qcl1:
        eps = qcl1[t]
        elems = [JoinBlock([Service(ep, t)]) for ep in eps]
        ub = UnionBlock(elems)
        views1 = views1 + [ub]
    return (views0, views1)
예제 #5
0
def start(service, *args, **kwargs):
    """
    Starts the various services used during API development
    """
    if service == 'all':
        s.info(
            f"Starting all services: $[{', '.join(map(str, [s for s in Service.SERVICE_LIST]))}]\n"
        )
        return [
            Service(s, *args, **kwargs).start() for s in Service.SERVICE_LIST
        ]
    service = Service(service, *args, **kwargs)
    s.info(f"Starting $[{service.name}]\n")
    service.start()
예제 #6
0
def getUnitaryStars(l, tl, genPred, prefixes):
    (qcl0, qcl1) = assignEndpoint(tl, l, genPred, prefixes)

    views0 = []
    views1 = []
    for cl in qcl0:
        l0 = qcl0[cl]
        vs = formStars2(l0)
        serv = [Service(cl, view) for view in vs]
        views0 = views0 + serv
    for t in qcl1:
        eps = qcl1[t]
        elems = [JoinBlock([Service(ep, t)]) for ep in eps]
        ub = UnionBlock(elems)
        views1 = views1 + [ub]
    return (views0, views1)
예제 #7
0
def getServices(services = {}):
	try:
		raw = etcdClient.read(config.ETCD_ROOT_KEY, recursive = True, sorted=True)
	except:
		moduleLogger.error('Failed to connect to etcd host %s:%s'%(config.ETCD_HOST, config.ETCD_PORT))
		return services

	rawServices = [x for x in raw.get_subtree() if x.dir and not x.key == config.ETCD_ROOT_KEY ]
	for service in rawServices:
		# split the key to obtain the service name
		name = service.key[1:].split('/')[1]
		# load the available backends
		try:
			backends = [Backend(**json.loads(x.value)) for x in service.leaves]
		except:
			backends = []

		if backends:
			# retrieve service if it already exists otherwise create a new one
			s = services.get(name, Service(name))

			for back in backends:
				s.addBackend(back)

			services[name] = s
		else:
			moduleLogger.debug('No backends found for service %s not including in list'%name)

	return services
예제 #8
0
    def __init__(self):
        log.startLogging(sys.stdout)

        reload(sys)
        sys.setdefaultencoding('UTF-8')

        #数据库
        import database
        GlobalManager.db = database.db
        GlobalManager.Session = database.Session

        #服务器配置
        from server import Server
        from services import Service
        server = Server(8100, "game")
        GlobalManager.tcpserver = server
        GlobalManager.netservice = Service('NetService')
        GlobalManager.tcpserver.serverFactory.addServiceChannel(
            GlobalManager.netservice)

        #开启进程监视
        GlobalManager.pbroot = PBRoot()
        GlobalManager.pbroot.addServiceChannel(GlobalManager.netservice)
        reactor.listenTCP(10000, BilateralFactory(GlobalManager.pbroot))

        #加入服务器逻辑函数
        import handle
 def test_create_service(self):
     ser = Service({
         "name": "test_name",
         "url": "test_url",
         "description": "test_description"
     })
     print(ser)
예제 #10
0
def getStarsM(l, tl, genPred, prefixes, c):
    (qcl0, qcl1) = assignEndpointM(tl, l, genPred, prefixes, c)
    views0 = []
    views1 = []
    #print qcl0
    #print qcl1
    for cl in qcl0:
        l0 = qcl0[cl]
        vs = formStars(l0)
        serv = [Service(cl, view) for view in vs]
        views0 = views0 + serv
    for t in qcl1:
        eps = qcl1[t]
        elems = [JoinBlock([Service(ep, t)]) for ep in eps]
        ub = UnionBlock(elems)
        views1 = views1 + [ub]
    return (postp2(views0), views1)
예제 #11
0
 def setUp(self):
     repoBooks = RepositoryBooks("Repobooks:")
     repoClients = RepositoryClients("Repoclients:")
     repoRental = RepositoryRentals("Reporentals:")
     validatorBooks = ValidateBook()
     validatorClients = ValidateClient()
     validatorRental = ValidateRental()
     self.Srv = Service(repoBooks, repoClients, repoRental, validatorRental, validatorBooks, validatorClients)
예제 #12
0
def getStarsS(l, tl, genPred, prefixes, c):
    qcl = assignEndpointS(tl, l, genPred, prefixes, c)
    views = []
    for cl in qcl:
        l0 = qcl[cl]
        vs = formStars(l0)
        serv = [Service(cl, view) for view in vs]
        views = views + serv
    return postp2(views)
예제 #13
0
    def __init__(self,name):
        """初始化远程调用对象
        @param port: int 远程分布服的端口号
        @param rootaddr: 根节点服务器地址
        """
        self._name = name
        self._factory = pb.PBClientFactory()
        self._reference = ProxyReference(self)
        self._service = Service('proxy')

        self._addr = None
예제 #14
0
def main(args):
    image_service = Service(language=args.lang,
                            output_file=args.output_file,
                            source=args.image_folder)
    all_images_in_source = image_service.all_images
    if args.clear:
        image_service.start_cleaning()
        return
    if args.delete:
        image_service.directory.delete_processed_images()
        return
    for image_name in all_images_in_source:
        processed_images = ProcessedImage(args.image_folder, image_name)
        image_service.start_processing(processed_images)
예제 #15
0
def getMetadata(idrac, port, file_collection_path, file_collection_time):
    meta_dict = {}
    response = requests.get(f"https://{user}:{passwd}@{idrac}/redfish/v1/", verify=False)
    json_response = response.json()
    service_data = Service(**json_response)
    serviceMeta = service_data.getMetadata()
    filename = getFileDescriptor(serviceMeta, idrac)
    try:
        fd = open(f"{file_collection_path}/output/{filename}", "a+")
    except FileNotFoundError as ex:
        if not os.path.exists(f"{file_collection_path}"):
            os.makedirs(file_collection_path)    
        fd = open(f"{file_collection_path}/output/{filename}", "a+")
    # meta_dict[idrac] = getFile
    return [serviceMeta[0], serviceMeta[1], fd, file_collection_path, file_collection_time ]
예제 #16
0
def status():
    '''
    View active services
    '''
    s.clear()
    title = text2art('WB CLI', font='swampland')
    run = click.style('\u2714', fg='green')
    stop = click.style('\u2718', fg='red')
    _status = [Service(s).status() for s in Service.SERVICE_LIST]
    status = [
        list(run if r == True else stop if r == False else r for r in st)
        for st in _status
    ]
    click.secho(title, fg='bright_cyan')
    click.echo(
        tabulate(status,
                 headers=['Service', 'Running'],
                 tablefmt="fancy_grid",
                 stralign="center"))
예제 #17
0
def fetchMetadata(idrac, port, file_collection_path, file_collection_time):
    meta_dict = {}
    url = f"https://{user}:{passwd}@{idrac}/redfish/v1/"
    response_code, json_response = apiGetCall(url, 'Root API', idrac)
    if response_code == 200:
        service_data = Service(**json_response)
        serviceMeta = service_data.getMetadata()
        filename = serviceMeta[0] + '_' + serviceMeta[1]+ '_' + idrac + '_' + getTimestamp() +".jsonl"
        # try:
        #     fd = open(f"{file_collection_path}/output/{filename}", "a+")
        # except FileNotFoundError as ex:
        #     if not os.path.exists(f"{file_collection_path}"):
        #         os.makedirs(file_collection_path)    
        #     fd = open(f"{file_collection_path}/output/{filename}", "a+")
        # meta_dict[idrac] = getFile
        return [serviceMeta[0], serviceMeta[1], filename, file_collection_path, file_collection_time]
    elif response_code == 408:
        print(json_response)
    else:
        print(f"{url} Failed with status code {response_code} and error Message {json_response}") 
예제 #18
0
def fetchMetadata(idrac, port, file_collection_path, file_collection_time, q):
    meta_dict = {}
    url = f"https://{user}:{passwd}@{idrac}/redfish/v1/"
    response_code, json_response = apiGetCall(url, 'Root API', idrac)
    if response_code == 200:
        # q.put_nowait(makeLogMessage("INFO", idrac, "Fetch Successfully"))
        service_data = Service(**json_response)
        serviceMeta = service_data.getMetadata()
        filename = serviceMeta[0] + '_' + serviceMeta[
            1] + '_' + idrac + '_' + getTimestamp() + ".jsonl"
        return [
            serviceMeta[0], serviceMeta[1], filename, file_collection_path,
            file_collection_time
        ]
    elif response_code == 408:
        q.put_nowait(makeLogMessage("ERROR", idrac, json_response))
    else:
        q.put_nowait(
            makeLogMessage(
                "ERROR", idrac,
                json_response['error']['@Message.ExtendedInfo'][0]['Message']))
예제 #19
0
 async def prepare(self):
     # 1.连接数据库
     await self.db_objects.connect()
     self.service = Service(self.db_objects)
예제 #20
0
class TestTaskResolution(TestCase):
    services = mk_services([
        Service('task1', 'name1', []),
        Service('task2', 'name2', []),
        Service('task3', 'name1', ['task1']),
        Service('task1', 'name2', []),
        Service('task4', 'name2', ['task3', 'task2']),
        Service('task5', 'name1', [], ['task1'])
    ])

    # Simple example of task resolution
    def test_simple(self):
        request = {
            'tasks': [
                {'task': 'task3', 'name': 'name1'}
            ]
        }
        response = {}
        resolution = _resolve(request, response, TestTaskResolution.services)
        expected = [('task1', 'name1'), ('task3', 'name1')]
        self.assertEqual(resolution, expected)

    # Recursive task resolution
    def test_recursive(self):
        request = {
            'tasks': [
                {'task': 'task4', 'name': 'name2'}
            ]
        }
        response = {}
        resolution = _resolve(request, response, TestTaskResolution.services)
        expected = [('task1', 'name1'), ('task3', 'name1'), ('task2', 'name2'), ('task4', 'name2')]
        self.assertEqual(resolution, expected)

    # Task resolution under the constraint that a specific
    # version of task1 was requested by the user
    def test_explicit(self):
        request = {
            'tasks': [
                {'task': 'task3', 'name': 'name1'},
                {'task': 'task1', 'name': 'name2'}
            ]
        }
        response = {}
        resolution = _resolve(request, response, TestTaskResolution.services)
        expected = [('task1', 'name2'), ('task3', 'name1')]
        self.assertEqual(resolution, expected)

    # Task resolution assuming the response is partially
    # provided by the user
    def test_partial_response(self):
        request = {
            'tasks': [
                {'task': 'task3', 'name': 'name1'},
                {'task': 'task2', 'name': 'name2'}
            ]
        }
        response = {
            'task1': []
        }
        resolution = _resolve(request, response, TestTaskResolution.services)
        expected = [('task1', None), ('task3', 'name1'), ('task2', 'name2')]
        self.assertEqual(resolution, expected)

    # Task resolution when one of the tasks has an optional dependence.
    # if the optional dependence is requested, it should be performed in advance
    def test_optional_dependence(self):
        request0 = {
            'tasks': [
                {'task': 'task5', 'name': 'name1'},
                {'task': 'task1', 'name': 'name2'}
            ]
        }
        request1 = {
            'tasks': [
                {'task': 'task5', 'name': 'name1'}
            ]
        }
        response = {}
        resolution0 = _resolve(request0, response, TestTaskResolution.services)
        resolution1 = _resolve(request1, response, TestTaskResolution.services)
        expected0 = [('task1','name2'), ('task5','name1')]
        expected1 = [('task5','name1')]
        self.assertEqual((resolution0, resolution1), (expected0, expected1))

    

    # When services are missing, appropriate exceptions are raised
    @raises(MissingService)
    def test_missing_service(self):
        request = {
            'tasks': [
                {'task': 'task3', 'name': 'name1'},
                {'task': 'task2', 'name': 'name2'},
                {'task': 'taskx', 'name': 'namex'}
            ]
        }
        response = {}
        resolution = _resolve(request, response, TestTaskResolution.services)
예제 #21
0
def main():
    op = -1
    while op != 0:

        print("Escolha uma opçao: \n")
        print("1  - Entrar com o valores atraves de um arquivo '.txt' : \n")
        print("2 - Entrar com os valores a partir do terminal: \n")
        print("3 - para sair digite 0: \n")
        op = int(input(""))

        if op == 1:
            print(
                "-------------------------------------------------------------------"
            )
            #ler os numeros atraves do arquivo .txt
            #caso queira mudar, basta alterar o arquivo
            arq = open('./vetor.txt')
            numeros = arq.read()
            arq.close()
            vetor = list(map(int, numeros.split(",")))
            print("Vetor de Entrada -> " + str(vetor))
            grafo = Service()
            capital = grafo.verificaCapital(vetor)

            if capital != False:
                vetorDistancias = grafo.transformaVetor(vetor, capital)
                print("\nvetor de Distancias -> " + str(vetorDistancias) +
                      "\n")
                grafo.traduzVetor(vetorDistancias)
            print("\n")

            print(
                "-------------------------------------------------------------------"
            )

        elif op == 2:
            print(
                "-------------------------------------------------------------------"
            )

            numeros = input(
                "Digite uma sequencia de numeros no seguinte padrão: 'x,y,z,.., w,' :\n "
            )
            vetor = list(map(int, numeros.split(",")))
            grafo = Service()
            print("\nVetor de Entrada-> " + str(vetor) + "\n")
            capital = grafo.verificaCapital(vetor)

            if capital != False:
                vetorDistancias = grafo.transformaVetor(vetor, capital)
                print("vetor de Distancias -> " + str(vetorDistancias))
                grafo.traduzVetor(vetorDistancias)
            print("\n")
            print(
                "-------------------------------------------------------------------"
            )

        elif op == 0:
            print("Exit\n")
            op = 0
        else:
            print("Digite uma opcao valida\n")
예제 #22
0
        files = settings.get_sql()
        repoBooks = RepositoryBooks("Repobooks:", files[0])
        repoClients = RepositoryClients("Repoclients:", files[1])
        repoRental = RepositoryRentals("Reporentals:", files[2])

    #____________________________________________

    #VALIDATORS
    validatorBooks = ValidateBook()

    validatorClients = ValidateClient()
    validatorRental = ValidateRental()

    #SERVICES

    Srv = Service(repoBooks, repoClients, repoRental, validatorRental,
                  validatorBooks, validatorClients)

    validatorInteger = ValidateInteger()
    validatorDate = ValidateDate()

    #hard-generate
    #________________BOOKS______________________________________________________
    repoBooks.add(Book(1, "The Secret Crusade", "Oliver Bowden"))
    repoBooks.add(Book(2, "The Illustrated Man", "Ray Bradbury"))
    repoBooks.add(Book(3, "The Glass Castle", "Jeannette Walls"))
    repoBooks.add(Book(4, "Still Alice", "Lisa Genova"))
    repoBooks.add(Book(5, "Olive, Again", "Elizabeth Strout"))
    repoBooks.add(Book(6, "The Nightshift Before Christmas", "Adam Kay"))
    repoBooks.add(Book(7, "The Tales of Beedle the Bard", "J K Rowling"))
    repoBooks.add(Book(8, "This is Going to Hurt", "Adam Kay"))
    repoBooks.add(Book(9, "Old new", "Oliver Bowden"))
예제 #23
0
menu.update_action("1", Service.show_all)
menu.update_action("2", Person.show_all)
menu.update_action("3", Account.show_all)
menu.update_action("4", Service.add)
menu.update_action("5", Person.add)
menu.update_action("6", Account.add)
dialog = Dialog.dialogs["add_account"]
dialog.update_select(3, Service.show_all)
dialog.update_select(4, Person.show_all)

Service.get_all_from_db()
print(Service.services)

Service({
    "name": "LinkedIn",
    "url": "https://www.linkedin.com",
    "description": "test_description LinkedIn"
})

print(Menu.menus)
Person.get_all_from_db()
print(Person.persons)

Person({
    "f_name": "John",
    "s_name": "Smith",
    "zip": 99999,
    "country": "United States",
    "industry": "Computers",
    "description": "test_description LinkedIn"
})
예제 #24
0
def p_service(p):
    """
    service : SERVICE uri LKEY group_graph_pattern_service RKEY
    """
    p[0] = Service(p[2], p[4])
예제 #25
0
        self.lista = []
​
        obj = {'id': 4, 'nome': "DDD", 'valor': 20}
        obj2 = {'id': 5, 'nome': "EEE", 'valor': 10}
        obj3 = {'id': 6, 'nome': "FFF", 'valor': 500}
​
        self.lista.append(obj)
        self.lista.append(obj2)
        self.lista.append(obj3)
​
    def listagemTest(self):
        repository = Mock()
​
        repository.listagem.return_value = self.lista
​
        service = Service(repository)
​
        return service.listagem()
​
    def obterTest(self):
        repository = Mock()
​
        repository.obter.return_value = self.lista[0]
​
        service = Service(repository)
​
        return service.obter(1)
​
    def obterErroTest(self):
        repository = Mock()
​