def setUp(self):
self.arango = Arango()
self.db_name = generate_db_name(self.arango)
# Test database cleanup
self.addCleanup(self.arango.delete_database,
name=self.db_name, safe_delete=True)
def setUp(self):
self.arango = Arango()
self.db_name = get_next_db_name(self.arango)
self.db = self.arango.create_database(self.db_name)
self.col_name = get_next_col_name(self.db)
self.col = self.db.create_collection(self.col_name)
# Create the vertex collection
self.vertex_col_name = get_next_col_name(self.db)
self.vertex_col = self.db.create_collection(self.vertex_col_name)
# Create the edge collection
self.edge_col_name = get_next_col_name(self.db)
self.edge_col = self.db.create_collection(
self.edge_col_name, is_edge=True
)
# Create the graph
self.graph_name = get_next_graph_name(self.db)
self.graph = self.db.create_graph(
name=self.graph_name,
edge_definitions=[{
"collection": self.edge_col_name,
"from": [self.vertex_col_name],
"to": [self.vertex_col_name]
}],
)
# Test database cleaup
self.addCleanup(self.arango.delete_database,
name=self.db_name, safe_delete=True)
def setUp(self):
self.arango = Arango()
self.username = generate_user_name(self.arango)
# Test user cleanup
self.addCleanup(self.arango.delete_user,
username=self.username,
safe_delete=True)
def setUp(self):
self.arango = Arango()
self.db_name = get_next_db_name(self.arango)
self.db = self.arango.create_database(self.db_name)
# Test database cleaup
self.addCleanup(self.arango.delete_database,
name=self.db_name, safe_delete=True)
def setUp(self):
self.arango = Arango()
self.db_name = generate_db_name(self.arango)
self.db = self.arango.create_database(self.db_name)
self.col_name = generate_col_name(self.db)
self.col = self.db.create_collection(self.col_name)
# Test database cleanup
self.addCleanup(self.arango.delete_database,
name=self.db_name,
safe_delete=True)
def setUp(self):
self.arango = Arango()
self.db_name = get_next_db_name(self.arango)
self.db = self.arango.create_database(self.db_name)
self.col_name01 = get_next_col_name(self.db)
self.col01 = self.db.create_collection(self.col_name01)
self.col_name02 = get_next_col_name(self.db)
self.col02 = self.db.create_collection(self.col_name02)
# Test database cleaup
self.addCleanup(self.arango.delete_database,
name=self.db_name, safe_delete=True)
def setUp(self):
self.arango = Arango()
self.db_name = generate_db_name(self.arango)
self.db = self.arango.create_database(self.db_name)
self.col_name = generate_col_name(self.db)
self.col = self.db.create_collection(self.col_name)
self.col.create_geo_index(["coord"])
self.col.create_skiplist_index(["value"])
self.col.create_fulltext_index(["text"])
# Test database cleanup
self.addCleanup(self.arango.delete_database,
name=self.db_name,
safe_delete=True)
def setUp(self):
# Create the test database
self.arango = Arango()
self.db_name = get_next_db_name(self.arango)
self.db = self.arango.create_database(self.db_name)
# Create the test vertex collection
self.vertex_col_name = get_next_col_name(self.db)
self.vertex_col = self.db.create_collection(self.vertex_col_name)
# Create the test edge collection
self.edge_col_name = get_next_col_name(self.db)
self.edge_col = self.db.create_collection(
self.edge_col_name, is_edge=True
)
# Create the test graph
self.graph_name = get_next_graph_name(self.db)
self.graph = self.db.create_graph(
name=self.graph_name,
edge_definitions=[{
"collection": self.edge_col_name,
"from": [self.vertex_col_name],
"to": [self.vertex_col_name]
}],
)
# Create a few test vertices
self.graph.create_vertex(
self.vertex_col_name,
data={
"_key": "vertex01",
"value": 1
}
)
self.graph.create_vertex(
self.vertex_col_name,
data={
"_key": "vertex02",
"value": 1
}
)
self.graph.create_vertex(
self.vertex_col_name,
data={
"_key": "vertex03",
"value": 1
}
)
# Test database cleaup
self.addCleanup(self.arango.delete_database,
name=self.db_name, safe_delete=True)
def connect_to_arango():
a = Arango(host=ARANGO_HOSTNAME,
port=ARANGO_PORT,
username='******',
password='******')
try:
user_info = dict()
user_info['username'] = '******'
user_info['passwd'] = 'joker'
user_info['active'] = True
db = a.create_database(ARANGODB_NAME, users=[user_info])
return db
except:
db = a.database(ARANGODB_NAME)
return db
def load_into_arango(author_file="/media/sf_Data/AMiner/AMiner-Author.txt", coauthor_file="/media/sf_Data/AMiner/AMiner-Coauthor.txt"):
print "Connecting to arango"
a = Arango(host="localhost", port=8529, username='******', password='******')
try:
user_info = dict()
user_info['username'] = '******'
user_info['passwd'] = 'joker'
user_info['active'] = True
db = a.create_database("aminer", users=[user_info])
except:
db = a.database("aminer")
try:
graph = db.create_graph("aminer_coauthors")
except:
graph = db.graph("aminer_coauthors")
try:
db.create_collection("authors")
graph.create_vertex_collection("authors")
db.create_collection("coauthors", is_edge=True)
graph.create_edge_definition(edge_collection="coauthors",
from_vertex_collections=["authors"],
to_vertex_collections=["authors"])
except:
pass
print "Reading AMiner Data"
authors, coauthor_relations = get_author_coauthors(author_file, coauthor_file)
print "Loading authors into arango"
for key in authors:
graph.create_vertex("authors", authors[key])
print "Building coauthor relations"
for author in coauthor_relations.keys():
for rel in coauthor_relations[author]:
graph.create_edge("coauthors", {"_from": "authors/" + unicode(author),
"_to": "authors/"+ unicode(rel[0]),
"w": rel[1]})
def setUp(self):
self.arango = Arango()
#! /usr/bin/env python
import ujson
import fileinput
import arango
from arango import Arango
from pprint import pprint
dbcnx = Arango(host="localhost")
try:
dbcnx.delete_database("eris0")
except arango.exceptions.DatabaseDeleteError:
pass
dbcnx.create_database("eris0")
db = dbcnx.database("eris0")
db.create_collection("events")
col = db.collection("events")
col.wait_for_sync = False
def main():
for line in fileinput.input():
line = line.strip()
event = None
try:
event = ujson.loads(line)
except ValueError:
continue
event["_key"] = event["id"]
del event["id"]
col.create_document(event)
import os
import sys
import uuid
from arango import Arango
db_name = 'fstest'
col_name = 'filesystem'
arango = Arango(host="localhost", port=8529)
try:
arango.delete_database(db_name)
except:
pass
db = arango.create_database(db_name)
graph = db.create_graph('filesystem')
fsnodes = db.create_collection('fsnodes')
graph.create_vertex_collection('fsnodes')
db.create_collection('contains', is_edge=True)
graph.create_edge_definition(edge_collection='contains',
from_vertex_collections=['fsnodes'],
to_vertex_collections=['fsnodes'])
for dirname, dirnames, filenames in os.walk(sys.argv[1]):
key = dirname.replace('/', '_')
d = dict(type='dir', dirname=dirname, _key=key)
graph.create_vertex('fsnodes', d)
for fname in filenames:
full_filename = filename = os.path.join(dirname, fname)
from arango import Arango
from dace.util import utility
from lac import log
ELASTICSEARCH_PORT = os.getenv('ELASTICSEARCH_PORT', 'localhost:9200')
es = Elasticsearch(ELASTICSEARCH_PORT)
ARANGO_HOST, ARANGO_PORT = os.getenv(
'ARANGO_PORT', 'localhost:8529').split(':')
ARANGO_ROOT_PASSWORD = os.getenv('ARANGO_ROOT_PASSWORD', '')
arango_server = Arango(
host=ARANGO_HOST, port=ARANGO_PORT,
password=ARANGO_ROOT_PASSWORD)
class IResourceManager(Interface):
def add_entry(self, key, value, mapping={}, id=None):
pass
def set_entry(self, key, value, id):
pass
def get_entry(self, id):
pass
def get_entries(self, key=None, query={"match_all": {}},
def setUp(self):
# Create the test database
self.arango = Arango()
self.db_name = generate_db_name(self.arango)
self.db = self.arango.create_database(self.db_name)
# Create the test vertex "from" collection
self.from_col_name = generate_col_name(self.db)
self.from_col = self.db.create_collection(self.from_col_name)
# Create the test vertex "to" collection
self.to_col_name = generate_col_name(self.db)
self.to_col = self.db.create_collection(self.to_col_name)
# Create the test edge collection
self.edge_col_name = generate_col_name(self.db)
self.edge_col = self.db.create_collection(self.edge_col_name,
is_edge=True)
# Create the test graph
self.graph_name = generate_graph_name(self.db)
self.graph = self.db.create_graph(
name=self.graph_name,
edge_definitions=[{
"collection": self.edge_col_name,
"from": [self.from_col_name],
"to": [self.to_col_name]
}],
)
# Create a few test "from" vertices
self.graph.create_vertex(self.from_col_name,
data={
"_key": "from01",
"value": 1
})
self.graph.create_vertex(self.from_col_name,
data={
"_key": "from02",
"value": 2
})
# Create a few test "to" vertices
self.graph.create_vertex(self.to_col_name,
data={
"_key": "to01",
"value": 1
})
self.graph.create_vertex(self.to_col_name,
data={
"_key": "to02",
"value": 2
})
self.graph.create_vertex(self.to_col_name,
data={
"_key": "to03",
"value": 3
})
# Create a few test edges
self.graph.create_edge(
self.edge_col_name, {
"_from": "{}/{}".format(self.from_col_name, "from01"),
"_to": "{}/{}".format(self.to_col_name, "to01"),
})
self.graph.create_edge(
self.edge_col_name, {
"_from": "{}/{}".format(self.from_col_name, "from02"),
"_to": "{}/{}".format(self.to_col_name, "to02"),
})
self.graph.create_edge(
self.edge_col_name, {
"_from": "{}/{}".format(self.from_col_name, "from02"),
"_to": "{}/{}".format(self.to_col_name, "to03"),
})
# Test database cleanup
self.addCleanup(self.arango.delete_database,
name=self.db_name,
safe_delete=True)
from arango import Arango
a = Arango(host="localhost", port=8529, username='******', password='******')
db = a.database("technodeminer")
