def add():
user_id = session['user_id']
user = User.get_by_id(user_id)
if user.acc_type == 'client':
flash('You need a service provider account to add services', 'error')
return redirect(url_for('index.index'))
if request.method == 'POST':
req = request.form
name = req.get('name')
desc = req.get('desc')
price = req.get('price')
categories = req.getlist('categories')
categories = ' '.join(categories)
Service.create(name=name,
desc=desc,
price=price,
categories=categories,
date_created=date.today().strftime('%d/%m/%Y'),
views=0,
favs=0,
username=user.username,
uid=user_id)
flash('Service created successfully', 'success')
return redirect(url_for('service.manage'))
return render_template('service/add.html', user=user)
def create_service(name: str, data: dict, user: str):
uuid: str = str(uuid4())
if name == "bruteforce":
Bruteforce.create(uuid)
elif name == "miner":
# First check for name then validate for special information
if "wallet_uuid" not in data:
return invalid_request
wallet_uuid: str = data["wallet_uuid"]
if not isinstance(wallet_uuid, str):
return invalid_request
if not exists_wallet(wallet_uuid):
return wallet_not_found
Miner.create(uuid, data["wallet_uuid"])
speed: float = 0
running: bool = False
if config["services"][name]["auto_start"]:
speed: float = register_service(data["device_uuid"], uuid, name, user)
if speed == -1:
speed: float = 0
else:
running: bool = True
service: Service = Service.create(uuid, data["device_uuid"], user, name,
speed, running)
return service.serialize
def test__model__service__export(self):
service = Service.create("my-device", "some-service", (1.1, 2.1, 3.2, 4.3, 5.5))
expected_result = (1.1, 2.1, 3.2, 4.3, 5.5)
actual_result = service.export()
self.assertEqual(expected_result, actual_result)
def test__model__service__overwrite(self):
service = Service.create("my-device", "some-service", (1.1, 2.1, 3.2, 4.3, 5.5))
service.overwrite((0.1, 0.2, 0.3, 0.4, 0.5))
self.assertEqual(0.1, service.allocated_cpu)
self.assertEqual(0.2, service.allocated_ram)
self.assertEqual(0.3, service.allocated_gpu)
self.assertEqual(0.4, service.allocated_disk)
self.assertEqual(0.5, service.allocated_network)
def test__model__service__create(self):
actual_result = Service.create("my-device", "some-service", (1.1, 2.1, 3.2, 4.3, 5.5))
self.assertEqual("my-device", actual_result.device_uuid)
self.assertEqual("some-service", actual_result.service_uuid)
self.assertEqual(1.1, actual_result.allocated_cpu)
self.assertEqual(2.1, actual_result.allocated_ram)
self.assertEqual(3.2, actual_result.allocated_gpu)
self.assertEqual(4.3, actual_result.allocated_disk)
self.assertEqual(5.5, actual_result.allocated_network)
mock.wrapper.session.add.assert_called_with(actual_result)
mock.wrapper.session.commit.assert_called_with()
def test__model__service__create(self):
actual_result = Service.create("service-uuid", "my-device", "its-me",
"ssh", 0.7, True)
self.assertIsInstance(actual_result, Service)
self.assertEqual("service-uuid", actual_result.uuid)
self.assertEqual("my-device", actual_result.device)
self.assertEqual("its-me", actual_result.owner)
self.assertEqual(True, actual_result.running)
self.assertEqual("ssh", actual_result.name)
self.assertEqual(22, actual_result.running_port)
self.assertEqual(0.7, actual_result.speed)
mock.wrapper.session.add.assert_called_with(actual_result)
mock.wrapper.session.commit.assert_called_with()
def create_service(serviceData: ServiceType):
"""
Create a new service
"""
service = Service.create(**serviceData, token=secrets.token_urlsafe(31))
msg = "Service created successfully."
log.info(f"{msg} - ID: {service.id}")
headers = {"Content-Location": f"/services/{service.id}"}
return http.JSONResponse({"message": msg},
status_code=201,
headers=headers)
def hardware_register(data: dict, microservice: str) -> dict:
# cpu_requirements, ram_req, gpu_req, disk_req, network_req
wl: Workload = wrapper.session.query(Workload).get(data["device_uuid"])
if wl is None:
return device_not_found
ser: Service = wrapper.session.query(Service).get(data["service_uuid"])
if ser is not None:
return service_already_running
other: List[Service] = wrapper.session.query(Service).filter_by(
device_uuid=data["device_uuid"]).all()
new: Tuple[float, float, float, float, float] = dict2tuple(data)
scales: Tuple[float, float, float, float, float] = generate_scale(new, wl)
scale_resources(other, scales)
wl.service(new)
ser: Service = Service.create(data["device_uuid"], data["service_uuid"],
new)
return_value: dict = {
"service_uuid": ser.service_uuid,
"cpu": ser.allocated_cpu * scales[0],
"ram": ser.allocated_ram * scales[1],
"gpu": ser.allocated_gpu * scales[2],
"disk": ser.allocated_disk * scales[3],
"network": ser.allocated_network * scales[4],
}
m.contact_user(data["user"],
wl.workload_notification("device-hardware-register"))
return return_value
def service():
service_data = {"name": fake.first_name(), "description": fake.text(100)}
service = Service.create(**service_data, token=secrets.token_urlsafe(31))
yield service
service.delete()
