def storeNodeInfo(baseDir, nodeName, steward, nodeip, nodeport, clientip,
clientport):
data = {}
vnodeip, vnodeport, vclientip, vclientport = getAddGenesisHAs(nodeip,
nodeport,
clientip,
clientport)
nodeAddr = vnodeip + ":" + str(vnodeport)
clientAddr = vclientip + ":" + str(vclientport)
data['steward'] = steward
data['nodeAddr'] = nodeAddr
data['clientAddr'] = clientAddr
newJsonData = json.dumps(data)
ledger = getLedger(baseDir, NodeInfoFile, storeHash=False,
isLineNoKey=False)
storedJsonData = ledger.get(nodeName)
if not storedJsonData:
storeToFile(baseDir, NodeInfoFile, newJsonData, nodeName,
storeHash=False, isLineNoKey=False)
elif not storedJsonData == newJsonData:
newRec = []
for key, jsonValue in ledger.iterator(include_key=True,
include_value=True):
if key != nodeName:
newRec.append((key, jsonValue))
newRec.append((nodeName, newJsonData))
ledger.reset()
for key, value in newRec:
storeToFile(baseDir, NodeInfoFile, value, key, storeHash=False,
isLineNoKey=False)
ledger.close()
def storeNodeInfo(baseDir, nodeName, steward, nodeip, nodeport, clientip,
clientport):
data = {}
vnodeip, vnodeport, vclientip, vclientport = getAddGenesisHAs(nodeip,
nodeport,
clientip,
clientport)
nodeAddr = vnodeip + ":" + str(vnodeport)
clientAddr = vclientip + ":" + str(vclientport)
data['steward'] = steward
data['nodeAddr'] = nodeAddr
data['clientAddr'] = clientAddr
newJsonData = json.dumps(data)
ledger = getLedger(baseDir, NodeInfoFile, storeHash=False,
isLineNoKey=False)
storedJsonData = ledger.get(nodeName)
if not storedJsonData:
storeToFile(baseDir, NodeInfoFile, newJsonData, nodeName,
storeHash=False, isLineNoKey=False)
elif not storedJsonData == newJsonData:
newRec = []
for key, jsonValue in ledger.iterator(include_key=True,
include_value=True):
if key != nodeName:
newRec.append((key, jsonValue))
newRec.append((nodeName, newJsonData))
ledger.reset()
for key, value in newRec:
storeToFile(baseDir, NodeInfoFile, value, key, storeHash=False,
isLineNoKey=False)
ledger.close()
def convert_to_json(self):
result = {
"appName": self.appName,
"error": self.error,
"success": self.success
}
return json.dumps(result)
def userNameList(request):
list1 = UserInfo.objects.all()
list2 = []
for i in list1:
list2.append(i.user_name)
list2 = json.dumps(list2)
# list2= serializers.serialize('json',list2)
return {'userNameList': list2}
def post(self, request):
if request.method == 'POST':
user_info_form = UserInfoForm(request.POST, instance=request.user)
if user_info_form.is_valid():
user_info_form.save()
return HttpResponse('{"status":"success"}',
content_type='application/json')
else:
return HttpResponse(json.dumps(user_info_form.errors),
content_type='application/json')
def create_help_provider(uid):
try:
jsonobj = create_json_object(request.args,
'subjects',
'schooltype',
'schoolyear',
'rating',
uid=uid)
return json.dumps({
'code': 'success',
'msg': '//',
'method': '/createuser->createhelpprovider',
'result': insert_one(help_provider, jsonobj)
})
except KeyError as err:
return json.dumps({
'code': 'error',
'msg': err.msg,
'method': '/createuser->createhelpprovider'
})
def create_user():
try:
jsonobj = create_json_object(request.args,
'username',
'prename',
'surname',
'email',
'phone',
'password',
'birthdate',
'picture',
'cur_pos',
'is_provider',
uid=str(uuid4()))
result = insert_one(user, jsonobj)
subresult = "null"
if request.args['is_provider'] == 'true':
subresult = create_help_provider(jsonobj['uid'])
return json.dumps({
'code': 'success',
'msg': '//',
'method': '/createuser',
'result': result,
'subprocess': subresult,
'user': {
'uid': jsonobj['uid']
}
})
except KeyError as err:
return json.dumps({
'code': 'error',
'msg': err.msg,
'method': '/createuser'
})
def route(uid, action):
if action == 'update':
jsonobj = create_json_object(request.args, 'key', 'value')
return json.dumps({
'code': 'success',
'msg': '//',
'method': '/' + uid + '/' + action,
'result': update(user, jsonobj)
})
elif action == 'get':
jsonobj = create_json_object(request.args, 'key')
return json.dumps({
'code': 'success',
'msg': '//',
'method': '/' + uid + '/' + action,
'result': find(user, jsonobj['key'])
})
return json.dumps({
'code': 'error',
'msg': '//',
'method': '/' + uid + '/' + action
})
def fake_get_duplicated_size_and_type():
return json.dumps([
{
"_id": "ObjectId('609c4f65db448caadd3cb8d6')",
"file": "C:\\Users\\migue\\.vscode\\extensions\\redhat.vscode-extension-bpmn-editor-0.8.3\\dist\\images\\[email protected]",
"createdDate": "datetime.datetime(2021, 5, 12, 22, 55, 48, 106000)",
"metadata": {
"width": 1152, "height": 768, "size": 884736, "type": "jpg"
}},
{
"_id": "ObjectId('609c4f65db448caadd3cb8dd')",
"file": "C:\\Users\\migue\\.vscode\\extensions\\redhat.vscode-extension-dmn-editor-0.8.3\\dist\\images\\[email protected]",
"createdDate": "datetime.datetime(2021, 5, 12, 22, 55, 49, 375000)",
"metadata": {
"width": 1152, "height": 768, "size": 884736, "type": "jpg"}
}])
def git_push_hook(webhook_parser: WebHookDataParser, handler: IssueHandler):
data = request.data
if len(data) == 0:
return make_response("", 200)
event_request = json.loads(data)
logger.info("Request {}".format(json.dumps(event_request)))
try:
ref = webhook_parser.parse(event_request)
except ParseError:
return make_response("", 200)
search = re.search(TRACKED_BRANCH_REGEXP, ref.ref_id)
if (ref.update_type == "UPDATE") and (search is not None) and (re.search(
WHITE_LISTED_REPOS, ref.repo_name)):
logger.info("Submit commit for processing")
__git_pool__.submit(process_hook_data, ref, handler)
else:
logger.info("Either repo {} or branch {} is not tracked".format(
ref.repo_name, ref.ref_id))
return make_response("", 200)
def _get_selection_criteria(source_nic,
reservation_id,
specific_number=None):
request = {
"isolation": "Exclusive",
"reservationId": reservation_id,
# The session number determines the order that traffic mirror sessions are
# evaluated when an interface is used by multiple sessions that have the
# same interface, but have different traffic mirror targets and traffic
# mirror filters. Traffic is only mirrored one time.
"poolId": source_nic,
"ownerId": SessionNumberService.OWNER_ID,
}
if not specific_number:
request["type"] = "NextAvailableNumericFromRange"
request["requestedRange"] = {"Start": 1, "End": 32766}
else:
request["type"] = "SpecificNumeric"
request["requestedItem"] = {"Value": specific_number}
selection_criteria = json.dumps(request)
return selection_criteria
def convert_to_json(self):
result = {'appName': self.appName, 'error': self.error, 'success': self.success}
return json.dumps(result)
def convert_to_json(self):
result = {'appName': self.appName, 'error': self.error, 'success': self.success}
return json.dumps(result)
from jsonpickle import json
while True:
my_soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_soc.settimeout(50)
my_soc.connect(('127.0.0.1', 6985))
req = input('Enter your request like "type target server":\n')
if req == '':
break
req_type, req_target, req_server = req.split()
query = {
'type': req_type,
'target': req_target,
'server': req_server,
}
while True:
try:
my_soc.send(bytes(json.dumps(query), encoding='utf_8'))
response = my_soc.recv(1024)
break
except Exception as e:
print(e.args, 'receive time out!')
print(response)
my_soc.close()
def randomRawAttr():
d = {"{}_{}".format(randomString(20), randint(100, 1000000)): "{}_{}".
format(randint(1000000, 1000000000000), randomString(50))}
return json.dumps(d)
def to_json(results):
if not results:
return
return json.dumps([r.__dict__ for r in results])
def randomRawAttr():
d = {
"{}_{}".format(randomString(20), randint(100, 1000000)):
"{}_{}".format(randint(1000000, 1000000000000), randomString(50))
}
return json.dumps(d)
def get_memory_history():
history = list(mem_history)
# to allow external access to the endpoint you need to add 'Access-Control-Allow-Origin': '*' to the headers
return json.dumps(history), 200, {'Access-Control-Allow-Origin': '*'}
def to_json(results):
if not results:
return
return json.dumps([r.__dict__ for r in results])
while True:
print('Waiting for client data...')
client_soc, address = soc.accept()
byteData = client_soc.recv(1024)
if byteData == b'':
continue
byteData = json.loads(str(byteData, encoding='utf_8'))
cached = DNSCacheDB.search((request.target == byteData['target']) & (request.type == byteData['type']))
if cached:
print('Founded in cache.')
cached = cached[0]
if int(time.time()) - cached['time'] <= cached['ttl']:
byteData['response'] = cached['result']
client_soc.send(bytes(json.dumps(byteData), encoding='utf_8'))
client_soc.close()
continue
else:
print('ttl is over!')
DNSCacheDB.remove((request.target == byteData['target']) & (request.type == byteData['type']))
print('Requested from server')
response = []
try:
while not response:
myResolver = dns.resolver.Resolver()
myResolver.nameservers = [byteData['server']]
dnsAnswer = myResolver.query(byteData['target'], byteData['type'])
print('DNS answer received')
authorative = bin(dnsAnswer.response.flags)[7]
