def post(self): form = CreateHostForm() hosts = Host.query.order_by(Host.type.asc(), Host.name.asc()).all() if form.validate_on_submit(): try: # Create database entry h = Host() h.name = form.name.data or None h.hostname = form.hostname.data or None h.region = form.region.data or None h.uri = form.uri.data or None h.active = False h.type = form.type.data or None h.username = form.username.data or None h.password = form.password.data or None db.session.add(h) db.session.commit() return redirect('/admin/hosts/') except: import traceback db.session.rollback() traceback.print_exc() return redirect('/admin/hosts/') return render_template('admin/hosts.html', form=form, hosts=hosts)
def get_executer_data(query, recursive=False, include_unattached=False): from app.models import Project, Datacenter, Group, Host host_fields = list(Host.FIELDS) group_fields = list(Group.FIELDS) if recursive: host_fields += ["all_tags", "all_custom_fields"] group_fields += ["all_tags", "all_custom_fields"] projects = Project.find(query) projects = cursor_to_list(projects) project_ids = [x["_id"] for x in projects] groups = Group.find({"project_id": {"$in": project_ids}}) groups = cursor_to_list(groups, fields=group_fields) group_ids = [x["_id"] for x in groups] if include_unattached: hosts = Host.find({}) else: hosts = Host.find({"group_id": {"$in": group_ids}}) hosts = cursor_to_list(hosts, fields=host_fields) datacenters = Datacenter.find({}) datacenters = cursor_to_list(datacenters) return { "datacenters": datacenters, "projects": projects, "groups": groups, "hosts": hosts }
def get(self, jwt, host_id, page_id, host_name=None): data = [] # If page_id is None do it the slow way. if page_id is None: # If no host_id is passed in get all hosts. if (host_id is None) and (host_name is None): # This is slow so lets just return an error # hosts = Host.get_all() return jsonify( error=True, msg= "Getting all hosts is slow. Please use the pagination endpoint at ./manage_host/page/" ) elif host_id: if Host.get_by_id(host_id): hosts = [Host.get_by_id(host_id)] else: hosts = [] elif host_name: hosts = [Host.get_by_hostname(host_name)] # Loop over results and get json form of host to return. if len(hosts) > 0: for host in hosts: temp_data = host.serialize() temp_data_services = Service.get_all_by_host_name( host.host_name) temp_data["all_services"] = [] for tds in temp_data_services: temp_data["all_services"].append(tds.serialize()) data.append(temp_data) pass return jsonify(data=data) else: return jsonify(error=True, msg="Host does not exist.") else: per_page = 10 totalhosts = Host.get_count() total_pages = floor(totalhosts / per_page) hosts = Host.get_by_page((page_id * per_page), per_page) if hosts is not None: for host in hosts: temp_data = host.serialize() temp_data_services = Service.get_all_by_host_name( host.host_name) temp_data["all_services"] = [] for tds in temp_data_services: temp_data["all_services"].append(tds.serialize()) data.append(temp_data) return jsonify({ "data": data, "totalhosts": totalhosts, "this_page": page_id, "more": (page_id < total_pages) })
def test_update_host(self): self.test_create_host() host = Host.find_one({"fqdn": TEST_HOST_1["fqdn"]}) payload = TEST_HOST_2 r = self.put_json("/api/v1/hosts/%s" % host._id, payload) self.assertEqual(r.status_code, 200) host = Host.find_one({"_id": host._id}) self.assertEqual(host.fqdn, TEST_HOST_2["fqdn"]) self.assertEqual(host.description, TEST_HOST_2["description"]) self.assertItemsEqual(host.tags, TEST_HOST_2["tags"])
def add_host(): if request.json: host = Host() host.uuid = str(uuid.uuid1()) host.name = request.json['name'] host.ip = request.json['ip'] host.port = request.json['port'] host.password = request.json['password'] host.status = request.json['status'] host.create_time = datetime.utcnow() db.session.add(host) try: db.session.commit() data = {'message': '新建数据成功'} except SQLAlchemyError as e: db.session.rollback() data = {'message': ' 新建数据失败'} else: data = {'message': '请求数据异常'} # return jsonify(data) # 支持跨域 response = make_response(jsonify(data)) response.headers['Access-Control-Allow-Origin'] = '*' response.headers['Access-Control-Allow-Methods'] = 'PUT,GET,POST,DELETE' response.headers[ 'Access-Control-Allow-Headers'] = 'Referer,Accept,Origin,User-Agent' return response
def test_delete_host(self): self.test_create_host() host = Host.find_one({"fqdn": TEST_HOST_1["fqdn"]}) r = self.delete("/api/v1/hosts/%s" % host._id) self.assertEqual(r.status_code, 200) data = json.loads(r.data) self.assertIn("data", data) host_data = data["data"] self.assertEqual(host_data["_id"], None) host = Host.find_one({"_id": host._id}) self.assertIsNone(host)
def test_update_per_reporter_staleness(db_create_host, models_datetime_mock): puptoo_stale_timestamp = models_datetime_mock + timedelta(days=1) input_host = Host( {"fqdn": "fqdn"}, display_name="display_name", reporter="puptoo", stale_timestamp=puptoo_stale_timestamp ) existing_host = db_create_host(host=input_host) assert existing_host.per_reporter_staleness == { "puptoo": { "last_check_in": models_datetime_mock.isoformat(), "stale_timestamp": puptoo_stale_timestamp.isoformat(), "check_in_succeeded": True, } } puptoo_stale_timestamp += timedelta(days=1) update_host = Host( {"fqdn": "fqdn"}, display_name="display_name", reporter="puptoo", stale_timestamp=puptoo_stale_timestamp ) existing_host.update(update_host) # datetime will not change because the datetime.now() method is patched assert existing_host.per_reporter_staleness == { "puptoo": { "last_check_in": models_datetime_mock.isoformat(), "stale_timestamp": puptoo_stale_timestamp.isoformat(), "check_in_succeeded": True, } } yupana_stale_timestamp = puptoo_stale_timestamp + timedelta(days=1) update_host = Host( {"fqdn": "fqdn"}, display_name="display_name", reporter="yupana", stale_timestamp=yupana_stale_timestamp ) existing_host.update(update_host) # datetime will not change because the datetime.now() method is patched assert existing_host.per_reporter_staleness == { "puptoo": { "last_check_in": models_datetime_mock.isoformat(), "stale_timestamp": puptoo_stale_timestamp.isoformat(), "check_in_succeeded": True, }, "yupana": { "last_check_in": models_datetime_mock.isoformat(), "stale_timestamp": yupana_stale_timestamp.isoformat(), "check_in_succeeded": True, }, }
def test_show_host(self): h = Host(**TEST_HOST_1) h.save() r = self.get("/api/v1/hosts/%s" % h._id) self.assertEqual(200, r.status_code) data = json.loads(r.data) self.assertIn("data", data) data = data["data"] self.assertIs(list, type(data)) self.assertEqual(1, len(data)) host_attrs = data[0] self.assertEqual(h.fqdn, host_attrs["fqdn"]) self.assertItemsEqual(h.tags, host_attrs["tags"]) self.assertEqual(h.description, host_attrs["description"])
def insert_one(self, host): """Insert a New Host""" token = self.__crypto.get_token() host = Host( name=host["name"], slug=host["slug"], type=host["type"], server=self.__crypto.encrypt(host["server"], token), auth_data=self.__crypto.encrypt(host["auth_data"], token), user=User.objects.get(pk=host["user_id"]), token=token ) host.save() return False if host.pk is None else host
def test_host_model_updated_timestamp(db_create_host): host = Host(account=ACCOUNT, canonical_facts={"fqdn": "fqdn"}) before_insert_commit = now() db_create_host(host) after_insert_commit = now() host.canonical_facts = {"fqdn": "ndqf"} before_update_commit = now() db.session.commit() after_update_commit = now() assert before_insert_commit < host.created_on < after_insert_commit assert before_update_commit < host.modified_on < after_update_commit
def get_export(): export_data = dict(hosts=[], groups=[]) args = merge_args_data(request.args, request.get_json(silent=True)) o_hosts = Host.objects() for o_host in o_hosts: export_data["hosts"].append(o_host.to_barn_dict()) o_groups = Group.objects() for o_group in o_groups: export_data["groups"].append(o_group.to_barn_dict()) if args.get("full", "").lower() in ("false", "no", "n", "0"): export_data = remove_empty_fields(export_data) response = None if args.get("format") in ("yaml", "yml"): response = make_response( yaml.dump(yaml.load(json.dumps(export_data)), indent=2)) response.headers.set('Content-Type', 'text/plain') else: response = make_response(json.dumps(export_data, indent=2)) response.headers.set('Content-Type', 'application/json') if "file" in args and args.get("file").lower() in ("true", "yes", "y", "1"): response.headers.set('Content-Disposition', 'attachment', filename='barn-export.%s' % (args.get("format"))) return response
def executer_data(): from app.models import Project, Datacenter, Group, Host if "projects" not in request.values: return json_response( { "errors": ["'projects' parameter is required for executer_data handler"] }, 400) project_names = request.values["projects"].split(",") projects = Project.find({"name": {"$in": project_names}}) projects = cursor_to_list(projects) project_ids = [x["_id"] for x in projects] groups = Group.find({"project_id": {"$in": project_ids}}) groups = cursor_to_list(groups) group_ids = [x["_id"] for x in groups] hosts = Host.find({"group_id": {"$in": group_ids}}) hosts = cursor_to_list(hosts) datacenters = Datacenter.find({}) datacenters = cursor_to_list(datacenters) results = { "datacenters": datacenters, "projects": projects, "groups": groups, "hosts": hosts } return json_response({"data": results})
def test_update_existing_host_fix_display_name_using_input_fqdn( db_create_host): # Create an "existing" host fqdn = "host1.domain1.com" existing_host = db_create_host(extra_data={ "canonical_facts": { "fqdn": fqdn }, "display_name": None }) # Clear the display_name existing_host.display_name = None db.session.commit() assert existing_host.display_name is None # Update the host expected_fqdn = "different.domain1.com" input_host = Host({"fqdn": expected_fqdn}, display_name="", reporter="puptoo", stale_timestamp=now()) existing_host.update(input_host) assert existing_host.display_name == expected_fqdn
def test_update_existing_host_fix_display_name_using_existing_fqdn( db_create_host): expected_fqdn = "host1.domain1.com" insights_id = generate_uuid() existing_host = db_create_host( extra_data={ "canonical_facts": { "fqdn": expected_fqdn, "insights_id": insights_id }, "display_name": None }) # Clear the display_name existing_host.display_name = None db.session.commit() assert existing_host.display_name is None # Update the host input_host = Host({"insights_id": insights_id}, display_name="", reporter="puptoo", stale_timestamp=now()) existing_host.update(input_host) assert existing_host.display_name == expected_fqdn
def addHost(host): print("addHost()") print("host:", host) # Required inputs: # account # canonical_facts canonical_facts = host.get("canonical_facts") found_host = Host.query.filter( Host.canonical_facts.comparator.contains(canonical_facts) | Host.canonical_facts.comparator.contained_by(canonical_facts)).first( ) if not found_host: print("Creating a new host") host = Host.from_json(host) host.save() return host.to_json(), 201 else: print("Updating host...") found_host.update(host) print("*** Updated host:", found_host) return found_host.to_json(), 200
def test_host_model_assigned_values(db_create_host, db_get_host): values = { "account": USER_IDENTITY["account_number"], "display_name": "display_name", "ansible_host": "ansible_host", "facts": [{ "namespace": "namespace", "facts": { "key": "value" } }], "tags": { "namespace": { "key": ["value"] } }, "canonical_facts": { "fqdn": "fqdn" }, "system_profile_facts": { "number_of_cpus": 1 }, "stale_timestamp": now(), "reporter": "reporter", } inserted_host = Host(**values) db_create_host(inserted_host) selected_host = db_get_host(inserted_host.id) for key, value in values.items(): assert getattr(selected_host, key) == value
def db_host(**values): data = { "account": USER_IDENTITY["account_number"], "display_name": "test-display-name", "ansible_host": "test-ansible-host", "canonical_facts": { "insights_id": generate_uuid(), "subscription_manager_id": generate_uuid(), "bios_uuid": generate_uuid(), "fqdn": "test-fqdn", "satellite_id": generate_uuid(), "rhel_machine_id": generate_uuid(), "ip_addresses": ["10.0.0.1"], "mac_addresses": ["aa:bb:cc:dd:ee:ff"], }, "facts": { "ns1": { "key1": "value1" } }, "tags": { "ns1": { "key1": ["val1", "val2"], "key2": ["val1"] }, "SPECIAL": { "tag": ["ToFind"] } }, "stale_timestamp": (now() + timedelta(days=randint(1, 7))).isoformat(), "reporter": "test-reporter", **values, } return Host(**data)
def host_add(): form = HostForm() if form.validate_on_submit(): data = form.data name_count = Host.query.filter_by(name=data["host_name"]).count() if name_count == 1: flash("主机名已经存在!", "err") return redirect(url_for("admin.host_add")) outernetip_num = Host.query.filter_by( outernet_ip=data["outernet_ip"]).count() if outernetip_num == 1: flash("外网IP已经存在!", "err") return redirect(url_for("admin.host_add")) host = Host( name=data["host_name"], system=data["system"], outernet_ip=data["outernet_ip"], intranet_ip=data["intranet_ip"], cpu=data["cpu"], memory=data["memory"], disk=data["disk"], username=data["username"], password=data["password"], port=data["port"], ssh_port=data["ssh_port"], status=data["status"], ) db.session.add(host) db.session.commit() flash("添加主机成功", "ok") return redirect(url_for("admin.host_list", page=1)) return render_template("admin/host_add.html", form=form)
def test_add_multiple_hosts(session): host1 = Host(hostname="test-hostname2", ll_ip="fe80::dead:beef:cafe:babe/64", ctrl_if="eno2", last_seen=datetime.now()) host2 = Host(hostname="test-hostname2", ll_ip="fe80::cafe:babe:dead:beaf/64", ctrl_if="eno2", last_seen=datetime.now()) session.add(host1) session.add(host2) session.commit() assert session.query(Host).count() == 2
def _add_host(host): """ Add or update a host Required parameters: - at least one of the canonical facts fields is required - account number """ validated_input_host_dict = HostSchema(strict=True).load(host) input_host = Host.from_json(validated_input_host_dict.data) if not current_identity.is_trusted_system and current_identity.account_number != input_host.account: raise InventoryException( title="Invalid request", detail= "The account number associated with the user does not match the account number associated with the " "host", ) existing_host = find_existing_host(input_host.account, input_host.canonical_facts) if existing_host: return update_existing_host(existing_host, input_host) else: return create_new_host(input_host)
def add_host(host): """ Add or update a host Required parameters: - at least one of the canonical facts fields is required - account number """ logger.debug("add_host(%s)" % host) account_number = host.get("account", None) if current_identity.account_number != account_number: raise InventoryException( title="Invalid request", detail="The account number associated with the user does not " "match the account number associated with the host") input_host = Host.from_json(host) canonical_facts = input_host.canonical_facts if not canonical_facts: raise InventoryException(title="Invalid request", detail="At least one of the canonical fact " "fields must be present.") existing_host = find_existing_host(account_number, canonical_facts) if existing_host: return update_existing_host(existing_host, input_host) else: return create_new_host(input_host)
def enc(host_id): from app.models import Host host_id = resolve_id(host_id) host = Host.find_one({ "$or": [{ "_id": host_id }, { "fqdn": host_id }, { "short_name": host_id }] }) if host is None: return json_response({"errors": ["Host not found"]}, 404) puppet_data = {"classes": [], "parameters": {}} for tag in host.all_tags: class_match = CLASS_EXPR.match(tag) if class_match is not None: puppet_data["classes"].append(class_match.groups()[0]) continue param_match = PARAM_EXPR.match(tag) if param_match is not None: k, v = param_match.groups() puppet_data["parameters"][k] = v continue env_match = ENV_EXPR.match(tag) if env_match is not None: puppet_data["environment"] = env_match.groups()[0] return yaml_response(puppet_data)
def deserialize_host_xjoin(data): host = Host( canonical_facts=data["canonical_facts"], display_name=data["display_name"], ansible_host=data["ansible_host"], account=data["account"], facts=data["facts"] or {}, tags={}, # Not a part of host list output system_profile_facts={}, # Not a part of host list output stale_timestamp=_deserialize_datetime(data["stale_timestamp"]), reporter=data["reporter"], ) for field in ("created_on", "modified_on"): setattr(host, field, _deserialize_datetime(data[field])) host.id = data["id"] return host
def get_all_hosts(): hosts = Host.get_all_hosts() hosts_list = [] for host in hosts: hosts_list.append((host.region, host.region)) return hosts_list
def post(self, jwt): data = [] if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() host_name = post_data.get('host_name') community_str = "" if host_name is None: return jsonify(error=True, msg="Missing host_name required field.") host = Host.get_by_hostname(host_name) if host is None: return jsonify(error=True) else: community_str = host._SNMPCOMMUNITY if community_str is None or len(community_str) == 0: return jsonify(error=True, msg="Missing SNMP community.") data.append({ "id": "1", "type_name": "snmp_cpuload", "type_alias": "SNMP CPU Load", "type_info": "Monitors the load of a CPU via SNMP" }) data.append({ "id": "2", "type_name": "snmp_traffic", "type_alias": "SNMP Traffic", "type_info": "Monitors bandwidth and traffic on servers, PCs, switches, etc. using SNMP" }) data.append({ "id": "3", "type_name": "snmp_memory", "type_alias": "SNMP Memory", "type_info": "Monitors the memory usage via SNMP" }) except Exception as e: return jsonify(error=True, msg=str(e)) return jsonify(data=data)
def test_host_model_timestamp_timezones(db_create_host): host = Host(account=ACCOUNT, canonical_facts={"fqdn": "fqdn"}, stale_timestamp=now(), reporter="ingress") db_create_host(host) assert host.created_on.tzinfo assert host.modified_on.tzinfo assert host.stale_timestamp.tzinfo
def _create_host(fqdn=None, display_name=None): canonical_facts = {} if fqdn: canonical_facts = {'fqdn': fqdn} host = Host(canonical_facts, display_name=display_name, account="00102") db.session.add(host) db.session.commit() return host
def get_active_hosts_by_type(type): hosts = Host.get_hosts_by_type(type) hosts_list = [] for host in hosts: if host.active: hosts_list.append((host.region, host.name)) return hosts_list
def create(): from app.models import Host hosts_attrs = dict( [x for x in request.json.items() if x[0] in Host.FIELDS]) if "fqdn_pattern" in request.json: if "fqdn" in hosts_attrs: return json_response({ "errors": [ "fqdn field is not allowed due to fqdn_pattern param presence" ] }) try: hostnames = list(expand_pattern(request.json["fqdn_pattern"])) except Exception as e: return json_exception(e) else: hostnames = [hosts_attrs["fqdn"]] del (hosts_attrs["fqdn"]) try: hosts_attrs["group_id"] = ObjectId(hosts_attrs["group_id"]) except (KeyError, InvalidId): hosts_attrs["group_id"] = None try: hosts_attrs["datacenter_id"] = ObjectId(hosts_attrs["datacenter_id"]) except (KeyError, InvalidId): hosts_attrs["datacenter_id"] = None for fqdn in hostnames: attrs = hosts_attrs attrs["fqdn"] = fqdn host = Host(**attrs) try: host.save() except Exception as e: return json_exception(e, 500) hosts = Host.find({"fqdn": {"$in": list(hostnames)}}) try: data = paginated_data(hosts.sort("fqdn")) except AttributeError as e: return json_exception(e, 500) return json_response(data, 201)
def platform_info(name='liudong-ubuntu', force_update=False): host = Host.objects.filter(name=name).first() if not host or force_update: if not host: host = Host(name=name) host.core_num = psutil.cpu_count() host.cpu = platform.machine() uname_result = platform.uname() host.system = uname_result[0] host.system_version = uname_result[2] host.system_arch = uname_result[4] sdiskusage = psutil.disk_usage('/') host.hard_disk = sdiskusage.total * 1.0 / (1024**3) mem = psutil.virtual_memory() host.memory = mem.total * 1.0 / (1024**3) host.save()
def test_host_model_constraints(field, value, db_create_host): values = {"account": ACCOUNT, "canonical_facts": {"fqdn": "fqdn"}, **{field: value}} if field == "reporter": values["stale_timestamp"] = now() host = Host(**values) with pytest.raises(DataError): db_create_host(host)
def add_host(request): request_dict = request.GET name = request_dict.get('name') force_update = request_dict.get('force_update') print request_dict data = {k: v for k, v in request_dict.items()} host = Host.objects.filter(name=name).first() if not host or force_update: if not host: host = Host(**data) host.save(force_insert=True) data = { 'msg': 'ok', 'status': 'ok' } return JsonResponse(data)