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()
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()
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()
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)
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()
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)
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
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)
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)
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)
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)
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
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)
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 ]
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"))
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}")
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']))
async def prepare(self):
# 1.连接数据库
await self.db_objects.connect()
self.service = Service(self.db_objects)
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)
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")
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"))
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"
})
def p_service(p):
"""
service : SERVICE uri LKEY group_graph_pattern_service RKEY
"""
p[0] = Service(p[2], p[4])
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()
