def init_detect(switch_name): result = {"errors": [], "network": "", "ip_offset": 0, "macs": []} if "ports" not in flask.request.json: result["errors"].append("Required parameters: 'ports'") return json.dumps(result) # Get the network IP from the dnsmasq configuration cmd = "grep listen-address /etc/dnsmasq.conf" process = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, universal_newlines=True) network_ip = process.stdout.split("=")[1] result["network"] = network_ip[:network_ip.rindex(".")] if len(result["network"].split(".")) != 3: logging.error("Wrong network IP from the dnsmasq configuration: %s" % result["network"]) result["errors"].append( "Wrong network IP from the dnsmasq configuration") # Get existing static IP from the dnsmasq configuration existing_ips = [] existing_macs = [] cmd = "grep ^dhcp-host /etc/dnsmasq.conf" process = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, universal_newlines=True) for line in process.stdout.split('\n'): if "," in line and not line.startswith("#"): existing_ips.append(line.split(",")[2]) existing_macs.append(line.split(",")[0][-17:]) result["macs"].append(line.split(",")[0][-17:]) logging.info("existing ips: %s" % existing_ips) logging.info("existing macs: %s" % existing_macs) # Check the node IP is available db = open_session() sw = db.query(RaspSwitch).filter(RaspSwitch.name == switch_name).first() ip_offset = sw.first_ip - 1 close_session(db) result["ip_offset"] = ip_offset for port in flask.request.json["ports"]: node_ip = "%s.%d" % (result["network"], (ip_offset + int(port))) if node_ip in existing_ips: result["errors"].append( "%s already exists in the DHCP configuration!" % node_ip) return json.dumps(result) # Expose TFTP files to all nodes (boot from the NFS server) tftp_files = glob('/tftpboot/rpiboot_uboot/*') for f in tftp_files: if os.path.isdir(f): new_f = '/tftpboot/%s' % os.path.basename(f) if not os.path.isdir(new_f): shutil.copytree(f, new_f) else: shutil.copy(f, '/tftpboot/%s' % os.path.basename(f)) return json.dumps(result)
def cancel(): """ Cancel the deployment (that is in the initialized state) """ db_session = open_session() db_user = db_session.query(User).filter_by(email=current_user.id).first() # Delete previous deployments still in initialized state old_dep = db_session.query(Deployment).filter_by( user_id=db_user.id, state="initialized").delete() close_session(db_session) return flask.redirect(flask.url_for("app.resources"))
def node_extend(arg_dict): result = {} # Check POST data if "nodes" not in arg_dict or "user" not in arg_dict: return json.dumps({ "parameters": { "user": "******", "nodes": ["name1", "name2"] } }) wanted = arg_dict["nodes"] user = arg_dict["user"] if len(user) == 0 or '@' not in user: for n in wanted: result[n] = "no_email" return json.dumps(result) # Get information about the requested nodes db = open_session() nodes = db.query(Schedule).filter( Schedule.node_name.in_(wanted)).filter(Schedule.owner == user).all() for n in nodes: # Allow users to extend their reservation 4 hours before the end_date if n.end_date - int(time.time()) < 4 * 3600: hours_added = int((n.end_date - n.start_date) / 3600) api_url = "https://api.grid5000.fr/stable/sites/%s/internal/oarapi/jobs/%s.json" % ( get_config()["g5k_site"], n.node_name) g5k_login = (arg_dict["g5k_user"], decrypt_password(arg_dict["g5k_password"])) json_data = { "method": "walltime-change", "walltime": "+%d:00" % hours_added } r = requests.post(url=api_url, auth=g5k_login, json=json_data) if r.status_code == 202: if r.json()["status"] == "Accepted": n.end_date += hours_added * 3600 result[n.node_name] = "success" else: error_msg = "failure: walltime modification rejected" logging.error(error_msg) logging.error(r.json()) result[n.node_name] = error_msg else: error_msg = "failure: wrong API return code %d" % r.status_code logging.error(error_msg) result[n.node_name] = error_msg else: result[ n. node_name] = "failure: it is too early to extend the reservation" close_session(db) # Build the result for n in wanted: if n not in result: result[n] = "failure" return json.dumps(result)
def ssh_put(): """ Create/update the SSH key of the user account """ my_ssh = flask.request.form.get("ssh_key") if my_ssh is not None and len(my_ssh) > 0: db_session = open_session() db_user = db_session.query(User).filter_by( email=current_user.id).first() db_user.ssh_key = my_ssh close_session(db_session) return flask.redirect(flask.url_for("app.user"))
def switch_nodes(switch_name): result = {"errors": [], "nodes": {}} db = open_session() sw = db.query(RaspSwitch).filter(RaspSwitch.name == switch_name).first() if sw.master_port > 0: result["nodes"][sw.master_port] = "pimaster" # Build the node information for n in db.query(RaspNode).filter(RaspNode.switch == sw.name).all(): result["nodes"][str(n.port_number)] = n.name close_session(db) return json.dumps(result)
def load_user(user_email): db = open_session() db_user = db.query(User).filter(User.email == user_email).first() auth_user = None if db_user is not None and db_user.is_authorized: flask_user = LoginUser() flask_user.email = db_user.email flask_user.is_admin = db_user.is_admin auth_user = flask_user close_session(db) return auth_user
def node_list(arg_dict): result = {} db = open_session() # Get the node properties for node in db.query(RaspNode).filter(RaspNode.name != "pimaster").all(): result[node.name] = {} for col_name in RaspNode.__table__.columns: name_str = str(col_name).split(".")[1] result[node.name][name_str] = getattr(node, name_str) close_session(db) return json.dumps(result)
def node_deployagain(arg_dict): result = {} for job_id in arg_dict["nodes"]: cmd = "iotlab-experiment -u %s -p %s reload -i %s" % ( arg_dict["iot_user"], decrypt_password( arg_dict["iot_password"]), job_id) process = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, universal_newlines=True) json_data = json.loads(process.stdout) if "id" in json_data: result[job_id] = "success" # Get information about the new job cmd = "iotlab-experiment -u %s -p %s get -i %d -p" % ( arg_dict["iot_user"], decrypt_password( arg_dict["iot_password"]), json_data["id"]) process = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, universal_newlines=True) job_data = json.loads(process.stdout) # Compute the dates of the job start_date = datetime.strptime(job_data["start_date"], "%Y-%m-%dT%H:%M:%SZ") start_date = start_date.replace(tzinfo=pytz.UTC) start_time = start_date.timestamp() end_time = start_time + job_data["submitted_duration"] * 60 # Add the new job to the schedule db = open_session() job_org = db.query(Schedule).filter( Schedule.node_name == job_id).first() schedule = Schedule() schedule.node_name = job_data["id"] schedule.owner = arg_dict["user"] schedule.bin = job_org.bin schedule.start_date = start_time schedule.end_date = end_time schedule.state = "ready" schedule.action_state = "" db.add(schedule) # Add the assigned nodes assigned_nodes = [] for n in job_data["nodes"]: assigned_nodes.append(n.split(".")[0] + "@" + n.split(".")[1]) nodes_str = ",".join(assigned_nodes) nodes_db = IotNodes() nodes_db.job_id = job_data["id"] nodes_db.assigned_nodes = nodes_str db.add(nodes_db) close_session(db) return json.dumps(result)
def switch_list(arg_dict): db = open_session() # Get the switches result = {} for s in db.query(RaspSwitch).all(): result[s.name] = {} for col_name in RaspSwitch.__table__.columns: name_str = str(col_name).split(".")[1] result[s.name][name_str] = getattr(s, name_str) close_session(db) return json.dumps(result)
def environment_list(arg_dict): db = open_session() # Get the environments result = {} for e in db.query(RaspEnvironment).all(): result[e.name] = {} for col_name in RaspEnvironment.__table__.columns: name_str = str(col_name).split(".")[1] result[e.name][name_str] = getattr(e, name_str) close_session(db) return json.dumps(result)
def node_deploying(): result = { "errors": [], "nodes": {}, "states": { "raspberry": [], "iot-lab": [], "g5k": [] } } db = open_session() for agent in db.query(Agent).filter(Agent.state == "connected").all(): try: r_data = post_data(db, current_user.email, agent.type, agent.token) r = requests.post(url="http://%s:%s/v1/user/node/mine" % (agent.ip, agent.port), timeout=POST_TIMEOUT, json=r_data) if r.status_code == 200: json_data = r.json() result["states"][agent.type] = json_data["states"] for node in json_data["nodes"]: # Sort the nodes by bin bin_name = json_data["nodes"][node].pop("bin") # Add the agent name to the node information json_data["nodes"][node]["agent"] = agent.name # No bin for nodes in 'configuring' state if len(bin_name) > 0: # Sort nodes by bin name if bin_name not in result["nodes"]: result["nodes"][bin_name] = { "raspberry": [], "iot-lab": [], "g5k": [] } result["nodes"][bin_name][agent.type].append( json_data["nodes"][node]) else: error_msg = "deploying error: wrong answer from the agent '%s' (return code %d)" % ( agent.name, r.status_code) logging.error(error_msg) result["errors"].append(error_msg) except (ConnectionError, ConnectTimeout): agent.state = "disconnected" error_msg = "agent '%s' does not respond" % agent.name result["errors"].append(error_msg) logging.exception(error_msg) except: error_msg = "connection failure to the agent '%s'" % agent.name result["errors"].append(error_msg) logging.exception(error_msg) close_session(db) return json.dumps(result)
def user_ssh(): msg = "" form_data = flask.request.form db = open_session() user = db.query(User).filter(User.email == current_user.email).first() if "ssh_key" in form_data: user.ssh_key = form_data["ssh_key"] msg = "SSH key updated!" else: msg = "Missing data in the request. SSH key unchanged!" close_session(db) return flask.redirect("/user/settings?msg=" + msg)
def set_power_port(switch_name, port, value): db = open_session() sw = db.query(RaspSwitch).filter(RaspSwitch.name == switch_name).first() snmp_address = "%s.%d" % (sw.poe_oid, sw.oid_offset + int(port)) cmd = "snmpset -v2c -c %s %s %s i %s" % (sw.community, sw.ip, snmp_address, value) close_session(db) subprocess.run(cmd.split(), check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) return True
def node_mine(arg_dict): if "user" not in arg_dict or "@" not in arg_dict["user"]: return json.dumps({ "parameters": "user: '******'" }) result = { "states": [], "nodes": {} } # Get the list of the states for the 'deploy' process py_module = import_module("%s.states" % get_config()["node_type"]) PROCESS = getattr(py_module, "PROCESS") for p in PROCESS["deploy"]: if len(p["states"]) > len(result["states"]): result["states"] = p["states"] db = open_session() # Get my nodes node_names = [] nodes = db.query(Schedule ).filter(Schedule.owner == arg_dict["user"] ).filter(Schedule.state != "configuring" ).all() for n in nodes: result["nodes"][n.node_name] = { "node_name": n.node_name, "bin": n.bin, "start_date": n.start_date, "end_date": n.end_date, "state": n.state, "action_state": n.action_state } nodes = db.query(RaspNode).filter(RaspNode.name.in_(result["nodes"].keys())).all() for n in nodes: result["nodes"][n.name]["ip"] = n.ip result["nodes"][n.name]["switch"] = n.switch result["nodes"][n.name]["port_number"] = n.port_number result["nodes"][n.name]["model"] = n.model result["nodes"][n.name]["serial"] = n.serial envs = db.query(ActionProperty ).filter(ActionProperty.node_name.in_(result["nodes"].keys()) ).filter(ActionProperty.prop_name.in_(["environment", "os_password"]) ).all() env_web = {} for e in envs: if e.prop_name == "environment": # Check if the environment provides a web interface if e.prop_value not in env_web: has_web = db.query(RaspEnvironment).filter(RaspEnvironment.name == e.prop_value ).first().web env_web[e.prop_value] = has_web if env_web[e.prop_value]: #result["nodes"][e.node_name]["url"] = "http://%s:8181" % result["nodes"][e.node_name]["ip"] # Hack for the PiSeduce cluster result["nodes"][e.node_name]["url"] = "https://pi%02d.seduce.fr" % ( int(result["nodes"][e.node_name]["port_number"])) result["nodes"][e.node_name][e.prop_name] = e.prop_value close_session(db) return json.dumps(result)
def save_env(n_name): """ Display the form to configure the 'save environment' action """ db_session = open_session() db_user = db_session.query(User).filter_by(email=current_user.id).first() deployment = db_session.query(Deployment).filter_by( user_id=db_user.id, node_name=n_name).filter(Deployment.state != "destroyed").first() env_name = deployment.environment close_session(db_session) return flask.render_template("form_save_env.html.jinja2", environment=env_name, node_name=n_name)
def make_deploy(): form_data = flask.request.form dep_name = None duration = None result = {} json_result = {"errors": []} for prop in form_data: if prop == "bin": bin_name = form_data[prop] else: node_name, _, prop_name = prop.rpartition("-") if prop_name == "agent": last_agent = form_data[prop] if last_agent not in result: result[last_agent] = {} result[last_agent][node_name] = {"node_bin": bin_name} else: result[last_agent][node_name][prop_name] = form_data[prop] if len(result) == 0: return flask.redirect("/user/configure?msg=%s" % "No data available to deploy nodes") db = open_session() for agent_name in result: # Send the user SSH key to the agent user_db = db.query(User).filter( User.email == current_user.email).first() if user_db.ssh_key is not None and len(user_db.ssh_key) > 256: for node in result[agent_name]: result[agent_name][node]["account_ssh_key"] = user_db.ssh_key agent = db.query(Agent).filter(Agent.name == agent_name).first() r_data = post_data(db, current_user.email, agent.type, agent.token) r_data["nodes"] = result[agent_name] r = requests.post(url="http://%s:%s/v1/user/deploy" % (agent.ip, agent.port), timeout=POST_TIMEOUT, json=r_data) if r.status_code == 200: r_json = r.json() if "error" in r_json and len(r_json["error"]) > 0: json_result["errors"].append(r_json["error"][0]) else: json_result.update(r.json()) else: json_result["errors"].append("wrong answer from the agent '%s'" % agent_name) close_session(db) if len(json_result["errors"]) > 0: return flask.redirect("/user/configure?msg=%s" % ",".join(json_result["errors"])) else: return flask.redirect("/user/manage") return json.dumps(json_result)
def ask_destruction(deployment_ids): """ Destroy multiple deployments from their id """ db_session = open_session() db_user = db_session.query(User).filter_by(email=current_user.id).first() for d in deployment_ids.split(","): deployment = db_session.query(Deployment).filter_by( id=d, user_id=db_user.id).first() if deployment is not None: deployment.process = 'destroy' deployment.state = select_process('destroy', deployment.environment)[0] close_session(db_session) return flask.redirect(flask.url_for("app.home"))
def pwd_put(): """ Create/update the password of the user account """ pwd = flask.request.form.get("password") confirm_pwd = flask.request.form.get("confirm_password") if pwd == confirm_pwd: db_session = open_session() db_user = db_session.query(User).filter_by( email=current_user.id).first() db_user._set_password = pwd close_session(db_session) return flask.redirect(flask.url_for("app.user")) else: return 'The two passwords are not identical!<a href="/user">Try again</a>'
def ask_redeploy(n_name): """ Deploy again the environment on the server """ db_session = open_session() db_user = db_session.query(User).filter_by(email=current_user.id).first() # Verify the node belongs to my deployments my_deployment = db_session.query(Deployment).filter_by( user_id=db_user.id, node_name=n_name).filter(Deployment.state != "destroyed").first() my_deployment.process = "deploy" my_deployment.state = select_process("deploy", my_deployment.environment)[0] close_session(db_session) return flask.redirect(flask.url_for("app.home"))
def temp_data_helper(agent_name=None, period_str=None): # Add the temperature consumption node_data = {} db = open_session() if agent_name is None or len(agent_name) == 0: agent_list = db.query(Agent).filter(Agent.type == "raspberry").filter( Agent.state == "connected").all() else: agent_list = db.query(Agent).filter(Agent.type == "raspberry").filter( Agent.state == "connected").filter(Agent.name == agent_name).all() for agent in agent_list: r_data = post_data(db, current_user.email, agent.type, agent.token) if isinstance(period_str, str) and len(period_str) > 0: r_data["period"] = period_str r = requests.post(url="http://%s:%s/v1/user/node/temperature" % (agent.ip, agent.port), timeout=POST_TIMEOUT, json=r_data) if r.status_code == 200: r_json = r.json() for cons in r_json: if agent.name not in node_data: node_data[agent.name] = {} node_name = cons["node"] if node_name not in node_data[agent.name]: node_data[agent.name][node_name] = {"consumptions": []} node_data[agent.name][node_name]["consumptions"].append({ "time": cons["time"], "consumption": cons["consumption"] }) else: logging.error( "Can not retrieve temperature monitoring values from agent '%s' (status code: %d)" % (agent.name, r.status_code)) close_session(db) # Remove the switch ports without consumptions or with every consumption equal to 0 for agent in list(node_data.keys()): agent_w_cons = False for node in list(node_data[agent].keys()): node_w_cons = False for cons in node_data[agent][node]["consumptions"]: if cons["consumption"] > 0: node_w_cons = True agent_w_cons = True if not node_w_cons: del node_data[agent][node] if not agent_w_cons: del node_data[agent] return node_data
def delete(el_type): data = flask.request.json props = ["name"] # Check if all properties belong to the POST data missing_data = [ key_data for key_data in props if key_data not in data.keys() ] if len(missing_data) == 0: if el_type == "node": db = open_session() existing = db.query(RaspNode).filter( RaspNode.name == data["name"]).all() for to_del in existing: db.delete(to_del) close_session(db) elif el_type == "switch": db = open_session() existing = db.query(RaspSwitch).filter( RaspSwitch.name == data["name"]).all() for to_del in existing: db.delete(to_del) close_session(db) elif el_type == "environment": db = open_session() existing = db.query(RaspEnvironment).filter_by( name=data["name"]).all() for to_del in existing: db.delete(to_del) close_session(db) elif el_type == "client": # Delete a DHCP client (IP address is in the 'name' attribute) delele_dhcp_ip(data["name"]) existing = [data["name"]] else: return json.dumps({"type_error": data["type"]}) return json.dumps({"delete": len(existing)}) else: return json.dumps({"missing": missing_data})
def get_poe_status(switch_name): db = open_session() sw = db.query(RaspSwitch).filter(RaspSwitch.name == switch_name).first() oid = sw.poe_oid cmd = "snmpwalk -v2c -c %s %s %s" % (sw.community, sw.ip, oid[:oid.rindex(".")]) close_session(db) process = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, universal_newlines=True) power_state = process.stdout.split("\n") return [p[-1] for p in power_state if len(p) > 0]
def ask_release_node(n_name): """ Delete the deployment associated to the server """ db_session = open_session() db_user = db_session.query(User).filter_by(email=current_user.id).first() # Get the deployment associated to the node my_deployment = db_session.query(Deployment).filter_by( user_id=db_user.id, node_name=n_name).filter(Deployment.state != "destroyed").first() if my_deployment is not None: my_deployment.process = 'destroy' my_deployment.state = select_process('destroy', my_deployment.environment)[0] close_session(db_session) return flask.redirect(flask.url_for("app.home"))
def add_node(): json_data = flask.request.json # Required properties to create Raspberry nodes node_props = [str(c).split(".")[1] for c in RaspNode.__table__.columns] missing_data = {} for prop in node_props: if prop not in json_data: # Create a missing prop without default values missing_data[prop] = [] if prop == "switch": db = open_session() switches = db.query(distinct(RaspSwitch.name)).all() if len(switches) == 0: missing_data[prop].append("no_values") else: for sw in switches: missing_data[prop].append(sw[0]) close_session(db) # Check if all properties belong to the POST data if len(missing_data) == 0: db = open_session() existing = db.query(RaspNode).filter( RaspNode.name == json_data["name"]).all() for to_del in existing: db.delete(to_del) new_node = RaspNode() new_node.name = json_data["name"] new_node.ip = json_data["ip"] new_node.switch = json_data["switch"] new_node.port_number = json_data["port_number"] new_node.model = json_data["model"] new_node.serial = json_data["serial"] db.add(new_node) close_session(db) return json.dumps({"node": json_data["name"]}) else: return json.dumps({"missing": missing_data})
def settings(): result = {} db = open_session() user = db.query(User).filter(User.email == current_user.email).first() if user is not None: status = "User" if user.is_admin: status = "Admin" ssh_key = "" if user.ssh_key is not None: ssh_key = user.ssh_key if os.path.isfile("vpn_keys/%s.conf" % current_user.email.replace("@", "_")): result = { "email": user.email, "ssh_key": ssh_key, "status": status, "vpn_key": True } else: result = { "email": user.email, "ssh_key": ssh_key, "status": status, "vpn_key": False } # G5k credentials if user.g5k_user is not None and len(user.g5k_user) > 0: result["g5k_user"] = user.g5k_user else: result["g5k_user"] = "******" if user.g5k_pwd is not None and len(user.g5k_pwd) > 0: result["g5k_pwd"] = True else: result["g5k_pwd"] = False # Iot-Lab credentials if user.iot_user is not None and len(user.iot_user) > 0: result["iot_user"] = user.iot_user else: result["iot_user"] = "******" if user.iot_pwd is not None and len(user.iot_pwd) > 0: result["iot_pwd"] = True else: result["iot_pwd"] = False close_session(db) return flask.render_template("settings.html", admin=current_user.is_admin, active_btn="user_settings", user=result)
def user_deployments(): cluster_desc = copy.deepcopy(get_cluster_desc()) user = current_user misc = {} session = open_session() db_user = session.query(User).filter_by(email=user.id).first() deployments = session.query(Deployment).filter( Deployment.state != "destroyed").filter_by( user_id=db_user.id).order_by(Deployment.node_name).all() deployment_info = {} for d in deployments: deployed = True if d.name not in deployment_info.keys(): # Deployment state is used to show/hide both the 'destroy' and the 'More info' buttons deployment_info[d.name] = { "name": d.name, "state": d.state, "user_id": d.user_id, "ids": [], "server_names": [], "server_infos": [] } deployment_info[d.name]["ids"].append(d.id) node_desc = cluster_desc["nodes"][d.node_name] deployment_info[d.name]["server_names"].append(node_desc["name"]) if d.environment is not None: if d.start_date is not None: s_date = datetime.datetime.strptime(str(d.start_date), '%Y-%m-%d %H:%M:%S') node_desc['starts_at'] = s_date.strftime("%d %b. at %H:%M") if d.state == 'lost': node_desc['last_state'] = d.temp_info env_desc = cluster_desc["environments"][d.environment] web_interface = False if 'web' in env_desc: web_interface = env_desc['web'] node_desc['number'] = int(node_desc["name"].split('-')[1]) node_desc['env'] = d.environment node_desc['state'] = d.state if d.state.endswith('_check'): node_desc["progress"] = d.temp_info else: node_desc["progress"] = 100 node_desc['password'] = d.system_pwd node_desc['web'] = web_interface node_desc['desc'] = env_desc['desc'] deployment_info[d.name]["server_infos"].append(node_desc) close_session(session) return {"deployments": list(deployment_info.values())}
def confirm_email(token): logger = logging.getLogger("LOGIN") logger.info("Receive the token '%s' to confirm email" % token) db_session = open_session() user_candidate = db_session.query(User).filter(User.email_confirmation_token == token).first() url = "Bad request: could not find the given token '%s'" % (token) if user_candidate is not None: user_candidate.email_confirmed = True if get_cluster_desc()['email_signup']: user_candidate.user_authorized = True url = flask.redirect(flask.url_for("login.confirmation_authorized_account")) else: url = flask.redirect(flask.url_for("login.confirmation_email")) close_session(db_session) return url
def user_pwd(): msg = "" form_data = flask.request.form db = open_session() user = db.query(User).filter(User.email == current_user.email).first() if "password" in form_data and "confirm_password" in form_data: if form_data["password"] == form_data["confirm_password"]: user.password = generate_password_hash(form_data["password"], method="sha256") msg = "Credentials updated!" else: msg = "The two passwords are different. Credentials unchanged!" else: msg = "Missing data in the request. Credentials unchanged!" close_session(db) return flask.redirect("/user/settings?msg=" + msg)
def user_loader(user_email): db_session = open_session() db_user = db_session.query(dbUser).filter( dbUser.email == user_email).first() ret_val = None if db_user is not None and db_user.user_authorized: user = User() user.id = db_user.email user.firstname = db_user.firstname user.lastname = db_user.lastname user.ssh_key = db_user.ssh_key user.is_admin = db_user.is_admin user.user_authorized = db_user.user_authorized ret_val = user close_session(db_session) return ret_val
def register_environment(arg_dict): db = open_session() node = db.query(Schedule ).filter(Schedule.node_name == arg_dict["node_name"] ).filter(Schedule.owner == arg_dict["user"] ).first() if node is None: close_session(db) msg = "No reservation for the node '%s'" % arg_dict["node_name"] logging.error("[%s] %s" % (arg_dict["node_name"], msg)) return json.dumps({ "error": msg }) # Check the image file does not exist yet file_name = os.path.basename(arg_dict["img_path"]) env_path = get_config()["env_path"] if os.path.exists("%s%s" % (env_path, file_name)): msg = "The image file '%s' already exists in the server. Please, rename this file." % file_name logging.error("[%s] %s" % (arg_dict["node_name"], msg)) return json.dumps({ "error": msg }) node_action = db.query(Action).filter(Action.node_name == node.node_name).first() if node_action is not None: db.delete(node_action) # The deployment is completed, add a new action node_action = new_action(node, db) # The deployment is completed, add a new action init_action_process(node_action, "reg_env") db.add(node_action) # Delete old values old_props = db.query(ActionProperty ).filter(ActionProperty.node_name == node.node_name ).filter(ActionProperty.prop_name.in_(["img_path", "env_name" ]) ).all() for p in old_props: db.delete(p) act_prop = ActionProperty() act_prop.node_name = node.node_name act_prop.prop_name = "img_path" act_prop.prop_value = arg_dict["img_path"] act_prop.owner = node.owner db.add(act_prop) act_prop = ActionProperty() act_prop.node_name = node.node_name act_prop.prop_name = "env_name" act_prop.prop_value = arg_dict["env_name"] act_prop.owner = node.owner db.add(act_prop) close_session(db) return json.dumps({ "success": "environment is registering" })