def donor(node):
"""
Display a list of users who made donations from the node (which will always
be one at the moment).
"""
donation_list = maindb.get_donations_from_node(node)
donor_names_list = []
for donation in donation_list:
donor_names_list.append(donation.donor.username)
return ",".join(donor_names_list)
def donor(node):
"""
Display a list of users who made donations from the node (which will always
be one at the moment).
"""
donation_list = maindb.get_donations_from_node(node)
donor_names_list = []
for donation in donation_list:
donor_names_list.append(donation.donor.username)
return ",".join(donor_names_list)
def add_new_node_to_db(node_string, node_info):
"""
<Purpose>
when new nodes come online, they may be not have the right data in
the database. This function ensures that the database has the
appropriate data and the node_info data matches with the
database data. There are four different situations and we want
to be in the fourth situation by the end of this function (if
we don't run into any error along the way.)
Situation1:
Database has no entry for node or and does not have a
donation record. The node has the donor key as the
owner key.
Situation2:
Database has entry for the node but does not have any
donation record. The node has the donor key as the
owner key.
Situation3:
Database has entry for the node and it has a
donation record. The node has the donor key as the
owner key.
Situation 4:
Database has entry for the node and it has a
donation record. The node has the per-node key
as the owner key.
<Arguments>
node_string - The node address in ip:port or NAT:port format
node_info - A dictionary that contains information about the node
<Exceptions>
NodeError - if the node does not have a valid state
DatabaseError - if there is any problem while creating node in database
or creating record of donation in database or problem retrieving user
object from the database
<Side Effects>
Database might get modified
<Return>
None
"""
log("Node in acceptdonationpublickey. Calling add_newnode_to_db()" +
" to check that node is correctly in database")
log("Looking for donor key for node: " + node_string)
log("Looking for the vessel that has the transition state in its 'userkeys'")
nodeID = _do_rsa_publickey_to_string(node_info['nodekey'])
(donated_vesselname, donor_key) = find_extra_vessel_name_and_donor_key(node_info, node_string)
try:
# Retrieve the node object if it's already in the database.
# This is for the case if a database entry was created,
# but the script ran into an error later on, causing the
# state of the node to be not updated.
database_nodeobject = maindb.get_node(nodeID)
except DoesNotExistError:
# If the node object does not exist in the database, add it.
# This is situation 1, where nothing has been done yet.
log("Database entry does not exist for node: " + node_string)
database_nodeobject = create_new_node_object(node_string, node_info, donated_vesselname)
log("Successfully added node to the database: " + node_string)
# We are finished adding node object, or retrieving node object from database.
log("Retrieved node object successfully with nodeID: " + nodeID +
" with the node: " + str(database_nodeobject))
# Check to see if the vessels owner key has been changed from the donor key
# to the per node key. This is either situation 2 or situation 3.
if donor_key != rsa.rsa_string_to_publickey(database_nodeobject.owner_pubkey):
# Note that this is the case for if there is multiple vessels in
# the same node that are in the acceptdonation state. On the first
# run a database record was created for one vessel and a donation
# record was created. If we are looking at a second vessel that is
# in the acceptdonation state, we want to raise an error and back out.
# To do this we compare the vessel name of our original donated vessel
# with the correct vesel name. If the names the same then everything is
# fine as we are just recovering the vessel. If the vesselname is not
# the same then this is a new vessel and we don't want to do anything.
# Currently we only accept one donation from one node. In the future
# this might change.
if donated_vesselname != database_nodeobject.extra_vessel_name:
raise NodeError("There is already a record of a vessel donated from node: " + node_string)
log("Database has nodeID but node has donor key")
log("Checking to make sure that the donation was credited")
# Check to see if the donor was credited.
donation_list = maindb.get_donations_from_node(database_nodeobject)
# If the donation lenght is 0 then the user has not been credited
# yet for their donation. This could be either due to this being
# a new node that was just added or it could be because we are
# recovering from a crash. This is in situation 2 if the length
# of donation_list is 0
if len(donation_list) == 0:
log("The donation has not been credited yet for node " + node_string)
create_donation_record(database_nodeobject, donor_key)
else:
log("The donation has already been credited for node " + node_string)
log("Attempting to change the owner for vessel: " + donated_vesselname)
# Convert the donation key to string format, and set the vessel owner key.
# We should be now in situation 3 where the node exists in the database
# and there is a donation record in the database.
donation_owner_pubkey_str = _do_rsa_publickey_to_string(donor_key)
backend.set_vessel_owner_key(database_nodeobject, donated_vesselname,
donation_owner_pubkey_str,
database_nodeobject.owner_pubkey)
log("Successfully changed the owner_key to " + donation_owner_pubkey_str)
return database_nodeobject
def check_node(node, readonly=True, lockserver_handle=None):
"""
<Purpose>
Check a node for problems. This will try to contact the node and will
compare the information retrieved from the node to the information we
have in our database. It will log and collect the information about
the problems. The problem information can be retrieved program
<Arguments>
node
The Node object of the node to be checked.
readonly
False if the function should mark the node in the database as inactive
or broken (and vessels released) when appropriate, True if it should
never change anything in the database. Default is True.
lockserver_handle
If an existing lockserver handle should be used for lock acquisitions,
it should be provided here. Otherwise, a new lockserver handle will
be used the during of this function call.
Note: no locking is done if readonly is True. That is, if there is
no reason to lock a node, there is no reason to provide a
lockserver_handle.
<Exceptions>
None
<Side Effects>
If readonly is False, the database may be updated appropriately based on
what the function sees. No changes are ever directly made to the nodes
through nodemanager communication regardless of the setting of readonly.
However, other scripts might take action based on database changes (e.g.
released vessel will quickly be cleaned up by the backend daemon).
<Returns>
None
"""
if not readonly:
must_destroy_lockserver_handle = False
if lockserver_handle is None:
must_destroy_lockserver_handle = True
lockserver_handle = lockserver.create_lockserver_handle()
if not readonly:
lockserver.lock_node(lockserver_handle, node.node_identifier)
# Be sure to release the node lock, if we are locking the node.
try:
# Get a fresh node record from the database. It might have changed before
# we obtained the lock.
node = maindb.get_node(node.node_identifier)
# The code beyond this point would be a good candidate for splitting out
# into a few smaller functions for readability.
donation_list = maindb.get_donations_from_node(node)
if len(donation_list) == 0:
_report_node_problem(node, "The node has no corresponding donation records. " +
"Not marking node broken, though.")
try:
nodeinfo = nodemanager.get_node_info(node.last_known_ip, node.last_known_port)
except NodemanagerCommunicationError:
_record_node_communication_failure(readonly, node)
_report_node_problem(node, "Can't communicate with node.")
return
try:
nodekey_str = rsa.rsa_publickey_to_string(nodeinfo["nodekey"])
except ValueError:
_mark_node_broken(readonly, node)
_report_node_problem(node, "Invalid nodekey: " + str(nodeinfo["nodekey"]))
return
# Check that the nodeid matches. If it doesn't, it probably means seattle
# was reinstalled or there is a different system at that address now.
if node.node_identifier != nodekey_str:
_mark_node_inactive(readonly, node)
_report_node_problem(node, "Wrong node identifier, the node reports: " + str(nodeinfo["nodekey"]))
# Not much more worth checking in this case.
return
# Check that the database thinks it knows the extra vessel name.
if node.extra_vessel_name == "":
_mark_node_broken(readonly, node)
_report_node_problem(node, "No extra_vessel_name in the database.")
# Not much more worth checking in this case.
return
# Check that a vessel by the name of extra_vessel_name exists on the node.
if node.extra_vessel_name not in nodeinfo["vessels"]:
_mark_node_broken(readonly, node)
_report_node_problem(node, "The extra_vessel_name in the database is a vessel name that doesn't exist on the node.")
# Not much more worth checking in this case.
return
extravesselinfo = nodeinfo["vessels"][node.extra_vessel_name]
vessels_in_db = maindb.get_vessels_on_node(node)
if len(extravesselinfo["userkeys"]) != 1:
_mark_node_broken(readonly, node)
_report_node_problem(node, "The extra vessel '" + node.extra_vessel_name +
"' doesn't have 1 user key, it has " +
str(len(extravesselinfo["userkeys"])))
else:
# Figure out which state the node is in according to the state key.
recognized_state_name = ""
for statename in statekeys:
if statekeys[statename] == extravesselinfo["userkeys"][0]:
recognized_state_name = statename
if not recognized_state_name:
_mark_node_broken(readonly, node)
_report_node_problem(node, "The extra vessel '" + node.extra_vessel_name +
"' doesn't have a recognized user/state key")
if len(vessels_in_db) == 0:
if recognized_state_name == "onepercentmanyevents" or recognized_state_name == "twopercent":
# We don't mark it as broken because it may be in transition by a
# transition script away from onepercentmanyevents. If the vessels
# in the db have been deleted first but the state key hasn't been
# changed yet, we might hit this. Also, it's not so bad to have it
# not be marked as broken when it's like this, as it has no vessels
# we know about, anyways, so we're not going to be giving questionable
# resources to users because of it.
_report_node_problem(node, "The node is in the " + recognized_state_name + " state " +
"but we don't have any vessels for it in the database.")
else:
if recognized_state_name != "onepercentmanyevents" and recognized_state_name != "twopercent":
# We don't mark it as broken because it may be in transition by a
# transition script. Also, we may have other states in the future
# besides onepercentmanyevents that have vessels. We don't want
# to make all of those nodes inactive if it's just an issue of
# someone forgot to update this script.
_report_node_problem(node, "The node is in the '" + recognized_state_name +
"' state but we have vessels for it in the database.")
known_vessel_names = []
for vessel in vessels_in_db:
known_vessel_names.append(vessel.name)
# Look for vessels on the node with our node ownerkey which aren't in our database.
for actualvesselname in nodeinfo["vessels"]:
vessel_ownerkey = nodeinfo["vessels"][actualvesselname]["ownerkey"]
try:
vessel_ownerkey_str = rsa.rsa_publickey_to_string(vessel_ownerkey)
except ValueError:
# At this point we aren't sure it's our node, but let's assume that if
# there's an invalid key then the node is broken, period.
_mark_node_broken(readonly, node)
_report_node_problem(node, "Invalid vessel ownerkey: " + str(vessel_ownerkey))
return
if vessel_ownerkey_str == node.owner_pubkey:
if actualvesselname not in known_vessel_names and actualvesselname != node.extra_vessel_name:
_mark_node_broken(readonly, node)
_report_node_problem(node, "The vessel '" + actualvesselname + "' exists on the node " +
"with the ownerkey for the node, but it's not in our vessels table.")
# Do some checking on each vessel we have in our database.
for vessel in vessels_in_db:
# Check that the vessel in our database actually exists on the node.
if vessel.name not in nodeinfo["vessels"]:
_mark_node_broken(readonly, node)
_report_node_problem(node, "The vessel '" + vessel.name + "' in our db doesn't exist on the node.")
continue
vesselinfo = nodeinfo["vessels"][vessel.name]
try:
vessel_ownerkey_str = rsa.rsa_publickey_to_string(vesselinfo["ownerkey"])
except ValueError:
_mark_node_broken(readonly, node)
_report_node_problem(node, "Invalid vessel ownerkey on a vessel in our db: " + str(vessel_ownerkey))
return
# Check that the owner key for the vessel is what we have for the node's owner key in our database.
if node.owner_pubkey != vessel_ownerkey_str:
_mark_node_broken(readonly, node)
_report_node_problem(node, "The vessel '" + vessel.name + "' doesn't have the ownerkey we use for the node.")
if not vesselinfo["advertise"]:
_mark_node_broken(readonly, node)
_report_node_problem(node, "The vessel '" + vessel.name + "' isn't advertising.")
# We're only concerned with non-dirty vessels as the backend daemon
# should be working on cleaning up dirty vessels.
if not vessel.is_dirty:
# Check that the user keys that have access are the ones that should have access.
users_with_access = maindb.get_users_with_access_to_vessel(vessel)
if len(users_with_access) != len(vesselinfo["userkeys"]):
_release_vessel(readonly, vessel)
_report_node_problem(node, "The vessel '" + vessel.name + "' reports " +
str(len(vesselinfo["userkeys"])) + " user keys, but we expected " + str(len(users_with_access)))
for user in users_with_access:
if rsa.rsa_string_to_publickey(user.user_pubkey) not in vesselinfo["userkeys"]:
_release_vessel(readonly, vessel)
_report_node_problem(node, "The vessel '" + vessel.name + "' doesn't have the userkey for user " + user.username + ".")
finally:
# We didn't do any locking if this readonly was True.
if not readonly:
# Release the lock
lockserver.unlock_node(lockserver_handle, node.node_identifier)
# Destroy the lockserver handle if we created it ourselves.
if must_destroy_lockserver_handle:
lockserver.destroy_lockserver_handle(lockserver_handle)
def check_node(node, readonly=True, lockserver_handle=None):
"""
<Purpose>
Check a node for problems. This will try to contact the node and will
compare the information retrieved from the node to the information we
have in our database. It will log and collect the information about
the problems. The problem information can be retrieved program
<Arguments>
node
The Node object of the node to be checked.
readonly
False if the function should mark the node in the database as inactive
or broken (and vessels released) when appropriate, True if it should
never change anything in the database. Default is True.
lockserver_handle
If an existing lockserver handle should be used for lock acquisitions,
it should be provided here. Otherwise, a new lockserver handle will
be used the during of this function call.
Note: no locking is done if readonly is True. That is, if there is
no reason to lock a node, there is no reason to provide a
lockserver_handle.
<Exceptions>
None
<Side Effects>
If readonly is False, the database may be updated appropriately based on
what the function sees. No changes are ever directly made to the nodes
through nodemanager communication regardless of the setting of readonly.
However, other scripts might take action based on database changes (e.g.
released vessel will quickly be cleaned up by the backend daemon).
<Returns>
None
"""
if not readonly:
must_destroy_lockserver_handle = False
if lockserver_handle is None:
must_destroy_lockserver_handle = True
lockserver_handle = lockserver.create_lockserver_handle()
if not readonly:
lockserver.lock_node(lockserver_handle, node.node_identifier)
# Be sure to release the node lock, if we are locking the node.
try:
# Get a fresh node record from the database. It might have changed before
# we obtained the lock.
node = maindb.get_node(node.node_identifier)
# The code beyond this point would be a good candidate for splitting out
# into a few smaller functions for readability.
donation_list = maindb.get_donations_from_node(node)
if len(donation_list) == 0:
_report_node_problem(
node, "The node has no corresponding donation records. " +
"Not marking node broken, though.")
try:
nodeinfo = nodemanager.get_node_info(node.last_known_ip,
node.last_known_port)
except NodemanagerCommunicationError:
_record_node_communication_failure(readonly, node)
_report_node_problem(node, "Can't communicate with node.")
return
try:
nodekey_str = rsa.rsa_publickey_to_string(nodeinfo["nodekey"])
except ValueError:
_mark_node_broken(readonly, node)
_report_node_problem(
node, "Invalid nodekey: " + str(nodeinfo["nodekey"]))
return
# Check that the nodeid matches. If it doesn't, it probably means seattle
# was reinstalled or there is a different system at that address now.
if node.node_identifier != nodekey_str:
_mark_node_inactive(readonly, node)
_report_node_problem(
node, "Wrong node identifier, the node reports: " +
str(nodeinfo["nodekey"]))
# Not much more worth checking in this case.
return
# Check that the database thinks it knows the extra vessel name.
if node.extra_vessel_name == "":
_mark_node_broken(readonly, node)
_report_node_problem(node, "No extra_vessel_name in the database.")
# Not much more worth checking in this case.
return
# Check that a vessel by the name of extra_vessel_name exists on the node.
if node.extra_vessel_name not in nodeinfo["vessels"]:
_mark_node_broken(readonly, node)
_report_node_problem(
node,
"The extra_vessel_name in the database is a vessel name that doesn't exist on the node."
)
# Not much more worth checking in this case.
return
extravesselinfo = nodeinfo["vessels"][node.extra_vessel_name]
vessels_in_db = maindb.get_vessels_on_node(node)
if len(extravesselinfo["userkeys"]) != 1:
_mark_node_broken(readonly, node)
_report_node_problem(
node, "The extra vessel '" + node.extra_vessel_name +
"' doesn't have 1 user key, it has " +
str(len(extravesselinfo["userkeys"])))
else:
# Figure out which state the node is in according to the state key.
recognized_state_name = ""
for statename in statekeys:
if statekeys[statename] == extravesselinfo["userkeys"][0]:
recognized_state_name = statename
if not recognized_state_name:
_mark_node_broken(readonly, node)
_report_node_problem(
node, "The extra vessel '" + node.extra_vessel_name +
"' doesn't have a recognized user/state key")
if len(vessels_in_db) == 0:
if recognized_state_name == "onepercentmanyevents" or recognized_state_name == "twopercent":
# We don't mark it as broken because it may be in transition by a
# transition script away from onepercentmanyevents. If the vessels
# in the db have been deleted first but the state key hasn't been
# changed yet, we might hit this. Also, it's not so bad to have it
# not be marked as broken when it's like this, as it has no vessels
# we know about, anyways, so we're not going to be giving questionable
# resources to users because of it.
_report_node_problem(
node, "The node is in the " + recognized_state_name +
" state " +
"but we don't have any vessels for it in the database."
)
else:
if recognized_state_name != "onepercentmanyevents" and recognized_state_name != "twopercent":
# We don't mark it as broken because it may be in transition by a
# transition script. Also, we may have other states in the future
# besides onepercentmanyevents that have vessels. We don't want
# to make all of those nodes inactive if it's just an issue of
# someone forgot to update this script.
_report_node_problem(
node, "The node is in the '" + recognized_state_name +
"' state but we have vessels for it in the database.")
known_vessel_names = []
for vessel in vessels_in_db:
known_vessel_names.append(vessel.name)
# Look for vessels on the node with our node ownerkey which aren't in our database.
for actualvesselname in nodeinfo["vessels"]:
vessel_ownerkey = nodeinfo["vessels"][actualvesselname]["ownerkey"]
try:
vessel_ownerkey_str = rsa.rsa_publickey_to_string(
vessel_ownerkey)
except ValueError:
# At this point we aren't sure it's our node, but let's assume that if
# there's an invalid key then the node is broken, period.
_mark_node_broken(readonly, node)
_report_node_problem(
node, "Invalid vessel ownerkey: " + str(vessel_ownerkey))
return
if vessel_ownerkey_str == node.owner_pubkey:
if actualvesselname not in known_vessel_names and actualvesselname != node.extra_vessel_name:
_mark_node_broken(readonly, node)
_report_node_problem(
node, "The vessel '" + actualvesselname +
"' exists on the node " +
"with the ownerkey for the node, but it's not in our vessels table."
)
# Do some checking on each vessel we have in our database.
for vessel in vessels_in_db:
# Check that the vessel in our database actually exists on the node.
if vessel.name not in nodeinfo["vessels"]:
_mark_node_broken(readonly, node)
_report_node_problem(
node, "The vessel '" + vessel.name +
"' in our db doesn't exist on the node.")
continue
vesselinfo = nodeinfo["vessels"][vessel.name]
try:
vessel_ownerkey_str = rsa.rsa_publickey_to_string(
vesselinfo["ownerkey"])
except ValueError:
_mark_node_broken(readonly, node)
_report_node_problem(
node, "Invalid vessel ownerkey on a vessel in our db: " +
str(vessel_ownerkey))
return
# Check that the owner key for the vessel is what we have for the node's owner key in our database.
if node.owner_pubkey != vessel_ownerkey_str:
_mark_node_broken(readonly, node)
_report_node_problem(
node, "The vessel '" + vessel.name +
"' doesn't have the ownerkey we use for the node.")
if not vesselinfo["advertise"]:
_mark_node_broken(readonly, node)
_report_node_problem(
node,
"The vessel '" + vessel.name + "' isn't advertising.")
# We're only concerned with non-dirty vessels as the backend daemon
# should be working on cleaning up dirty vessels.
if not vessel.is_dirty:
# Check that the user keys that have access are the ones that should have access.
users_with_access = maindb.get_users_with_access_to_vessel(
vessel)
if len(users_with_access) != len(vesselinfo["userkeys"]):
_release_vessel(readonly, vessel)
_report_node_problem(
node, "The vessel '" + vessel.name + "' reports " +
str(len(vesselinfo["userkeys"])) +
" user keys, but we expected " +
str(len(users_with_access)))
for user in users_with_access:
if rsa.rsa_string_to_publickey(
user.user_pubkey) not in vesselinfo["userkeys"]:
_release_vessel(readonly, vessel)
_report_node_problem(
node, "The vessel '" + vessel.name +
"' doesn't have the userkey for user " +
user.username + ".")
finally:
# We didn't do any locking if this readonly was True.
if not readonly:
# Release the lock
lockserver.unlock_node(lockserver_handle, node.node_identifier)
# Destroy the lockserver handle if we created it ourselves.
if must_destroy_lockserver_handle:
lockserver.destroy_lockserver_handle(lockserver_handle)
def add_new_node_to_db(node_string, node_info):
"""
<Purpose>
when new nodes come online, they may be not have the right data in
the database. This function ensures that the database has the
appropriate data and the node_info data matches with the
database data. There are four different situations and we want
to be in the fourth situation by the end of this function (if
we don't run into any error along the way.)
Situation1:
Database has no entry for node or and does not have a
donation record. The node has the donor key as the
owner key.
Situation2:
Database has entry for the node but does not have any
donation record. The node has the donor key as the
owner key.
Situation3:
Database has entry for the node and it has a
donation record. The node has the donor key as the
owner key.
Situation 4:
Database has entry for the node and it has a
donation record. The node has the per-node key
as the owner key.
<Arguments>
node_string - The node address in ip:port or NAT:port format
node_info - A dictionary that contains information about the node
<Exceptions>
NodeError - if the node does not have a valid state
DatabaseError - if there is any problem while creating node in database
or creating record of donation in database or problem retrieving user
object from the database
<Side Effects>
Database might get modified
<Return>
None
"""
log("Node in acceptdonationpublickey. Calling add_newnode_to_db()" +
" to check that node is correctly in database")
log("Looking for donor key for node: " + node_string)
log("Looking for the vessel that has the transition state in its 'userkeys'")
nodeID = _do_rsa_publickey_to_string(node_info['nodekey'])
(donated_vesselname, donor_key) = find_extra_vessel_name_and_donor_key(node_info, node_string)
try:
# Retrieve the node object if it's already in the database.
# This is for the case if a database entry was created,
# but the script ran into an error later on, causing the
# state of the node to be not updated.
database_nodeobject = maindb.get_node(nodeID)
except DoesNotExistError:
# If the node object does not exist in the database, add it.
# This is situation 1, where nothing has been done yet.
log("Database entry does not exist for node: " + node_string)
database_nodeobject = create_new_node_object(node_string, node_info, donated_vesselname)
log("Successfully added node to the database: " + node_string)
# We are finished adding node object, or retrieving node object from database.
log("Retrieved node object successfully with nodeID: " + nodeID +
" with the node: " + str(database_nodeobject))
# Check to see if the vessels owner key has been changed from the donor key
# to the per node key. This is either situation 2 or situation 3.
if donor_key != rsa.rsa_string_to_publickey(database_nodeobject.owner_pubkey):
# Note that this is the case for if there is multiple vessels in
# the same node that are in the acceptdonation state. On the first
# run a database record was created for one vessel and a donation
# record was created. If we are looking at a second vessel that is
# in the acceptdonation state, we want to raise an error and back out.
# To do this we compare the vessel name of our original donated vessel
# with the correct vesel name. If the names the same then everything is
# fine as we are just recovering the vessel. If the vesselname is not
# the same then this is a new vessel and we don't want to do anything.
# Currently we only accept one donation from one node. In the future
# this might change.
if donated_vesselname != database_nodeobject.extra_vessel_name:
raise NodeError("There is already a record of a vessel donated from node: " + node_string)
log("Database has nodeID but node has donor key")
log("Checking to make sure that the donation was credited")
# Check to see if the donor was credited.
donation_list = maindb.get_donations_from_node(database_nodeobject)
# If the donation lenght is 0 then the user has not been credited
# yet for their donation. This could be either due to this being
# a new node that was just added or it could be because we are
# recovering from a crash. This is in situation 2 if the length
# of donation_list is 0
if len(donation_list) == 0:
log("The donation has not been credited yet for node " + node_string)
create_donation_record(database_nodeobject, donor_key)
else:
log("The donation has already been credited for node " + node_string)
log("Attempting to change the owner for vessel: " + donated_vesselname)
# Convert the donation key to string format, and set the vessel owner key.
# We should be now in situation 3 where the node exists in the database
# and there is a donation record in the database.
donation_owner_pubkey_str = _do_rsa_publickey_to_string(donor_key)
backend.set_vessel_owner_key(database_nodeobject, donated_vesselname,
donation_owner_pubkey_str,
database_nodeobject.owner_pubkey)
log("Successfully changed the owner_key to " + donation_owner_pubkey_str)
return database_nodeobject