Esempio n. 1
0
    def create_or_update(self, label: str, data: dict, context: Transaction):
        self.create_node(label=label, name=data['name'])

        check_node = self.get_node(self.node())
        exits = False
        if type(check_node) is Node:
            exits = True
            self.node(check_node)

        self.assign_attributes(data)

        if exits is False:
            context.create(self.node())
            print(f"Created {label}")
        else:
            context.push(self.node())
            print(f"Updated {label}")
Esempio n. 2
0
    def _create_client_nodes(self, tx: Transaction, skipt_empty: bool):
        for client in Client.select():
            if skipt_empty and not client.connections and not client.probe_reqs:
                continue

            client_data = to_dict(client)
            client_data.pop("mac")
            client_node = tx.evaluate(
                "MERGE (_:Client {mac:$mac}) SET _ += $client RETURN _",
                client=client_data,
                mac=self._parse_mac(client.mac))

            for connection in client.connections:
                bss_data = to_dict(connection.bss)
                bss_data.pop("bssid")
                bss_node = tx.evaluate(
                    "MERGE (_:BSS {bssid:$bssid}) SET _ += $bss RETURN _",
                    bss=bss_data,
                    bssid=self._parse_mac(connection.bss.bssid))

                connection_rel = Relationship(client_node, "CONNECTED",
                                              bss_node, **to_dict(connection))
                tx.create(connection_rel)

            for probe in client.probe_reqs:
                ess_data = to_dict(probe.ess)

                ess_node = tx.evaluate(
                    "MERGE (_:ESS {ssid:$ssid}) SET _ += $ess RETURN _",
                    ess=ess_data,
                    ssid=probe.ess.ssid)

                announcement = Relationship(client_node, "PROBES", ess_node,
                                            **to_dict(probe))
                tx.create(announcement)
Esempio n. 3
0
    def _create_bss_nodes(self, tx: Transaction):
        for bss in BasicServiceSet.select():
            bss_data = to_dict(bss)
            bss_data.pop("bssid")
            bss_node = tx.evaluate(
                "MERGE (_:BSS {bssid:$bssid}) SET _ += $bss RETURN _",
                bss=bss_data,
                bssid=self._parse_mac(bss.bssid))

            if bss.ess is not None:
                ess_data = to_dict(bss.ess)

                ess_node = tx.evaluate(
                    "MERGE (_:ESS {ssid:$ssid}) SET _ += $ess RETURN _",
                    ess=ess_data,
                    ssid=bss.ess.ssid)

                announcement = Relationship(bss_node, "ANNOUNCES", ess_node)
                tx.create(announcement)
Esempio n. 4
0
def test_should_fail_on_tx_separate_object():
    tx = Transaction(FakeGraph())
    with raises(TypeError):
        tx.separate(object())
Esempio n. 5
0
def test_should_fail_on_tx_push_object():
    tx = Transaction(FakeGraph())
    with raises(TypeError):
        tx.push(object())
Esempio n. 6
0
def merge_nodes_and_relationships(tx: Transaction, nodes: List[Node],
                                  relationships: List[Relationship]):
    for node in nodes:
        tx.merge(node)
    for rel in relationships:
        tx.merge(rel)
Esempio n. 7
0
def commit_cypher_query(cypher_query):
    tr = Transaction(g)
    tr.run(cypher_query)
    tr.commit()
Esempio n. 8
0
def commit_cypher_query_numpy(cypher_query):
    tr = Transaction(g)
    array = tr.run(cypher_query).to_ndarray()

    return array
Esempio n. 9
0
def commit_cypher_query_set(cypher_query_set):
    tr = Transaction(g)
    for cypher_query in cypher_query_set:
        tr.run(cypher_query)
    tr.commit()
Esempio n. 10
0
    def _create_client_aggregated_nodes(self, tx: Transaction,
                                        skipt_empty: bool):
        agg_nodes = dict()

        for client in Client.select():
            if skipt_empty and not client.connections and not client.probe_reqs:
                continue

            if not client.connections:
                # Only export single clients when they have connections
                probes = frozenset(probe.ess.ssid
                                   for probe in client.probe_reqs)
                agg_node = agg_nodes.get(probes, list())
                agg_node.append(client)
                agg_nodes[probes] = agg_node
                continue

            client_data = to_dict(client)
            client_data.pop("mac")
            client_node = tx.evaluate(
                "MERGE (_:Client {mac:$mac}) SET _ += $client RETURN _",
                client=client_data,
                mac=self._parse_mac(client.mac))

            for connection in client.connections:
                bss_data = to_dict(connection.bss)
                bss_data.pop("bssid")
                bss_node = tx.evaluate(
                    "MERGE (_:BSS {bssid:$bssid}) SET _ += $bss RETURN _",
                    bss=bss_data,
                    bssid=self._parse_mac(connection.bss.bssid))

                connection_rel = Relationship(client_node, "CONNECTED",
                                              bss_node, **to_dict(connection))
                tx.create(connection_rel)

            for probe in client.probe_reqs:
                ess_data = to_dict(probe.ess)

                ess_node = tx.evaluate(
                    "MERGE (_:ESS {ssid:$ssid}) SET _ += $ess RETURN _",
                    ess=ess_data,
                    ssid=probe.ess.ssid)

                announcement = Relationship(client_node, "PROBES", ess_node,
                                            **to_dict(probe))
                tx.create(announcement)

        for probe_ssids, clients in agg_nodes.items():

            group_id = hash(probe_ssids)

            self.cmd.pfeedback(
                "[i] Aggregating {} clients probing for: {}".format(
                    len(clients), ", ".join(probe_ssids)))

            client_data = {
                self._parse_mac(client.mac): True
                for client in clients
            }
            client_node = tx.evaluate(
                "MERGE (_:Client {group_id:$group_id}) SET _ += $client RETURN _",
                client=client_data,
                group_id=group_id)

            for probe_ssid in probe_ssids:
                ess_node = tx.evaluate("MERGE (_:ESS {ssid:$ssid}) RETURN _",
                                       ssid=probe_ssid)

                announcement = Relationship(client_node, "PROBES", ess_node)
                tx.create(announcement)
Esempio n. 11
0
 def create_or_merge_relationship(self, relation: Relationship,
                                  context: Transaction):
     if self.graph().exists(relation) is True:
         context.merge(relation)
     else:
         context.create(relation)
Esempio n. 12
0
 def _get_latest(self, tx: Transaction, sender_id: str):
     matcher = NodeMatcher(tx)
     query = matcher.match(sender_id).order_by(
         "_.created_at desc").limit(1)._query_and_parameters()[0]
     latest = tx.evaluate(query)
     return latest