def main():
face = Face()
keychain = KeyChain()
face.setCommandSigningInfo(keychain, keychain.getDefaultCertificateName())
running = True
# The following line doesn't work sometimes
# interest = Interest("/icear-server/calc")
interest = Interest(Name("/icear-server/calc"))
param_msg = SegmentParameterMessage()
param_msg.segment_parameter.name.component.append(
bytes("example-data", "utf-8"))
param_msg.segment_parameter.start_frame = 2
param_msg.segment_parameter.end_frame = 3
op = param_msg.segment_parameter.operations.components.add()
op.model = bytes("deeplab", "utf-8")
op.flags = 0
op = param_msg.segment_parameter.operations.components.add()
op.model = bytes("la_muse", "utf-8")
op.flags = 0
interest.name.append(ProtobufTlv.encode(param_msg))
interest.mustBeFresh = True
interest.interestLifetimeMilliseconds = 4000.0
interest.setCanBePrefix(True)
def on_data(_, data):
# type: (Interest, Data) -> None
nonlocal running
print(data.name.toUri())
print(data.content.toBytes())
running = False
def on_timeout(_):
nonlocal running
print("Timeout")
running = False
def on_nack(_, nack):
# type: (Interest, NetworkNack) -> None
nonlocal running
print("NACK")
print(nack.getReason())
running = False
face.expressInterest(interest, on_data, on_timeout, on_nack)
while running:
face.processEvents()
time.sleep(0.01)
face.shutdown()
def connection_test(self):
interest = Interest("/localhost/nfd/faces/events")
interest.mustBeFresh = True
interest.canBePrefix = True
interest.interestLifetimeMilliseconds = 1000
try:
def empty(*_args, **_kwargs):
pass
self.face.expressInterest(interest, empty, empty, empty)
return True
except (ConnectionRefusedError, BrokenPipeError, OSError):
return False
async def face_event(self):
last_seq = -1
retry_time = 3000
retry_count_limit = 60000 // retry_time
retry_count = 0
while self.running and self.face:
name = Name("/localhost/nfd/faces/events")
face_interest = Interest()
if last_seq >= 0:
name.appendSequenceNumber(last_seq + 1)
face_interest.canBePrefix = False
else:
face_interest.mustBeFresh = True
face_interest.canBePrefix = True
logging.info("Face event notification stream %s", name.toUri())
face_interest.name = name
# face_interest.interestLifetimeMilliseconds = 60000
face_interest.interestLifetimeMilliseconds = retry_time
ret = await fetch_data_packet(self.face, face_interest)
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
if isinstance(ret, Data):
retry_count = 0
last_seq = ret.name[-1].toSequenceNumber()
face_event = FaceEventNotificationMessage()
try:
ProtobufTlv.decode(face_event, ret.content)
dic = self.face_event_to_dict(face_event.face_event_notification)
dic['seq'] = str(last_seq)
dic['time'] = timestamp
self.emit('face event', dic)
self.event_list.append(dic)
except RuntimeError as exc:
logging.fatal('Decode failed %s', exc)
last_seq = -1
elif ret is None:
if retry_count >= retry_count_limit:
logging.info("No response: face event")
last_seq = -1
retry_count = 0
else:
retry_count += 1
else:
logging.info("NFD is not running: start reconnection")
self.start_reconnection()
return
await asyncio.sleep(0.1)
async def send_temp_interest(self):
"""
Send a temperature interest to the producer
"""
interest_name = Name(self.prefix).append(str(int(time.time()) - 1))
interest = Interest(interest_name)
interest.interestLifetimeMilliseconds = 4000
logging.info('Fetching {}'.format(str(interest.getName())))
print('Fetching {}'.format(str(interest.getName())))
data = await fetch_data_packet(self.face, interest)
if isinstance(data, Data):
self.process_temp_data(data)
else:
logging.info('Failed to fetch {}'.format(str(interest.getName())))
async def run():
async def face_loop():
nonlocal face, running
while running:
face.processEvents()
await asyncio.sleep(0.01)
running = True
face = Face()
event_loop = asyncio.get_event_loop()
face_task = event_loop.create_task(face_loop())
interest = Interest(Name("/localhost/gitsync/notif/temprepo/master"))
interest.mustBeFresh = True
interest.canBePrefix = True
interest.interestLifetimeMilliseconds = 60000
data = await fetch_data_packet(face, interest)
if isinstance(data, Data):
print("Notif", data.content.toBytes().decode())
else:
print("Failed")
running = False
await face_task
def exec_ndn_ping():
nonlocal last_ping_data
name = request.form['name']
can_be_prefix = request.form['can_be_prefix'] == 'true'
must_be_fresh = request.form['must_be_fresh'] == 'true'
try:
interest_lifetime = float(
request.form['interest_lifetime']) * 1000.0
except ValueError:
interest_lifetime = 4000.0
interest = Interest(name)
interest.canBePrefix = can_be_prefix
interest.mustBeFresh = must_be_fresh
interest.interestLifetimeMilliseconds = interest_lifetime
st_time = time.time()
ret = run_until_complete(fetch_data_packet(server.face, interest))
ed_time = time.time()
response_time = '{:.3f}s'.format(ed_time - st_time)
if isinstance(ret, Data):
response_type = 'Data'
name = ret.name.toUri()
if ret.metaInfo.type is not None:
content_type = decode_content_type(ret.metaInfo.type)
else:
content_type = "None"
if ret.metaInfo.freshnessPeriod is not None:
freshness_period = "{:.3f}s".format(
ret.metaInfo.freshnessPeriod / 1000.0)
else:
freshness_period = "None"
if ret.metaInfo.finalBlockId is not None:
final_block_id = ret.metaInfo.finalBlockId.toEscapedString()
else:
final_block_id = "None"
signature_type = type(ret.signature).__name__
last_ping_data = ret.content.toBytes()
return redirect(
url_for('ndn_ping',
response_time=response_time,
response_type=response_type,
name=name,
content_type=content_type,
freshness_period=freshness_period,
final_block_id=final_block_id,
signature_type=signature_type,
download='/download/ping-data'))
elif isinstance(ret, NetworkNack):
response_type = 'NetworkNack'
reason = decode_nack_reason(ret.getReason())
return redirect(
url_for('ndn_ping',
response_time=response_time,
response_type=response_type,
name=name,
reason=reason))
elif ret is None:
response_type = 'Timeout'
return redirect(
url_for('ndn_ping',
response_time=response_time,
response_type=response_type,
name=name))
else:
logging.info("No response: ndn-ping")
return redirect('/')
async def run(local_repo_path: str, repo_prefix: str):
async def face_loop():
nonlocal face, running
while running:
face.processEvents()
await asyncio.sleep(0.01)
options = {'cloning': False}
running = True
face = Face()
keychain = KeyChain()
face.setCommandSigningInfo(keychain, keychain.getDefaultCertificateName())
event_loop = asyncio.get_event_loop()
face_task = event_loop.create_task(face_loop())
storage = FileStorage(local_repo_path)
producer = GitProducer(face, Name(repo_prefix).append("objects"), storage)
refs = []
empty_cnt = 0
while empty_cnt < 2 and running:
cmd = sys.stdin.readline().rstrip("\n\r")
# print("<<", cmd, file=sys.stderr)
if cmd == "capabilities":
print("push")
print("fetch")
print("option")
print("")
sys.stdout.flush()
elif cmd.startswith("option"):
opt_name, opt_val = cmd.split()[1:]
if opt_name == "cloning":
options['cloning'] = (opt_val == 'true')
print("ok")
else:
print("unsupported")
sys.stdout.flush()
elif cmd == "list" or cmd == "list for-push":
interest = Interest(Name(repo_prefix).append("ref-list"))
data = await fetch_data_packet(face, interest)
if isinstance(data, Data):
reflist = data.content.toBytes().decode("utf-8")
print(reflist)
if reflist.strip() == "":
refs = {}
else:
refs = [
item.split(" ")[1]
for item in reflist.strip().split("\n")
]
refs = {name.split("/")[-1] for name in refs}
else:
print("error: Couldn't connect to",
repo_prefix,
file=sys.stderr)
running = False
print("")
sys.stdout.flush()
elif cmd.startswith("fetch"):
fetcher = GitFetcher(face,
Name(repo_prefix).append("objects"), storage)
while True:
# Fetch files
hash_name, ref_name = cmd.split()[1:]
fetcher.fetch(hash_name, "commit")
await fetcher.wait_until_finish()
# Set refs file
ref_file_path = os.path.join(local_repo_path, ref_name)
with open(ref_file_path, 'w') as f:
f.write(hash_name)
# Read commands for next fetch
cmd = sys.stdin.readline().rstrip("\n\r")
if not cmd.startswith("fetch"):
break
print("")
sys.stdout.flush()
elif cmd.startswith("push"):
while True:
# Push commands
# TODO: DELETE ALL HARDCODED THINGS
# TODO: MAKE DATA AND INTEREST REAL
branch, commit, _ = parse_push(cmd, local_repo_path)
repo_name = repo_prefix.split("/")[-1]
# Create Branch if not exist
if branch not in refs:
print("Non-existing branch. Try to create...",
file=sys.stderr)
interest = Interest(
Name(LOCAL_CMD_PREFIX).append("create-branch").append(
repo_name).append(branch))
data = await fetch_data_packet(face, interest)
if isinstance(data, Data):
result = struct.unpack("i", data.content.toBytes())[0]
if result == 1:
print("Creation succeeded", file=sys.stderr)
elif result == 2:
print("Creation is FAILED", file=sys.stderr)
print("error refs/heads/{} FAILED".format(branch))
break
else:
print("Creation is PENDING", file=sys.stderr)
print("error refs/heads/{} PENDING".format(branch))
break
else:
print("error: Couldn't connect to",
interest.name.toUri(),
file=sys.stderr)
break
# BranchInfo Interest
interest = Interest(
Name(repo_prefix).append("branch-info").append(branch))
data = await fetch_data_packet(face, interest)
branchinfo = None
if isinstance(data, Data):
branchinfo = pickle.loads(data.content.toBytes())
if branchinfo is None or 'custodian' not in branchinfo.__dict__:
print("ERROR Interest got no response: ",
interest.name,
file=sys.stderr)
print("error refs/heads/{} DISCONNECTED".format(branch))
break
# Push Interest
interest = Interest(
Name(branchinfo.custodian).append("push").append(
repo_name).append(branch))
interest.applicationParameters = commit.encode("utf-8")
interest.appendParametersDigestToName()
interest.interestLifetimeMilliseconds = 20000
interest.mustBeFresh = True
data = await fetch_data_packet(face, interest)
if isinstance(data, Data):
result = struct.unpack("i", data.content.toBytes())[0]
if result == 1:
print("OK push succeeded",
interest.name,
file=sys.stderr)
print("ok refs/heads/{}".format(branch))
elif result == 2:
print("ERROR push failed",
interest.name,
file=sys.stderr)
print("error refs/heads/{} FAILED".format(branch))
else:
print("PROCESSING push is not finished yet",
interest.name,
file=sys.stderr)
print("error refs/heads/{} PENDING".format(branch))
else:
print("ERROR Interest got no response: ",
interest.name,
file=sys.stderr)
print("error refs/heads/{} DISCONNECTED".format(branch))
break
# Read commands for next fetch
cmd = sys.stdin.readline().rstrip("\n\r")
if not cmd.startswith("push"):
break
print("")
sys.stdout.flush()
elif cmd == "":
empty_cnt += 1
else:
pass
producer.cancel()
running = False
await face_task
