def unpackage(self, data):
terminatorLen = len(dfs_socket.DATA_TERMINATOR)
success = True
try:
work = serializer.deserialize(data)
except Exception, ex:
success = False
def _get_ensemble(self):
"""Gets the latest ensemble.
Returns:
Ensemble.
"""
try:
# Wait for data ID byte.
while not self._conn.read() == chr(self.DATA_ID):
rospy.loginfo_throttle(5.0, "Waiting for packet start byte...")
if rospy.is_shutdown():
break
# Read all ensemble data.
packet = bitstring.BitStream("0x{:02X}".format(self.DATA_ID))
characters = self._conn.read(size=self.OUTPUT_DATA_SIZE - 1)
for char in characters:
packet.append("0x{:02X}".format(ord(char)))
return deserialize(packet, self._frame_id)
except select.error as (code, msg):
# Set SIGINT as KeyboardInterrupt correctly, because pyserial has
# problems.
if code == errno.EINTR:
raise KeyboardInterrupt()
# Otherwise, reraise.
raise
def deserialize(self):
"""
Load all collections from disk
@raise CX if there is an error in deserialization
"""
for collection in (
self._settings,
self._distros,
self._repos,
self._profiles,
self._images,
self._systems,
self._mgmtclasses,
self._packages,
self._files,
):
try:
if not serializer.deserialize(collection):
raise ""
except:
raise CX(
"serializer: error loading collection %s. Check /etc/cobbler/modules.conf"
% collection.collection_type())
def startcoinservers(coincontroller, exenames , envars, startupstatcheckfreqscnds, appdata):
userfile = appdata + '\\' + 'stakenanny' + '\\' + 'user.sav'
if path.exists(userfile):
user = deserialize(userfile )
else:
user = User()
user.set_pwd(getpasswd())
serialize(user, userfile)
#starteachserver(coincontroller, exenames, envars, user.get_pwd(), appdata, startupstatcheckfreqscnds, rpcports)
gevent.joinall([
gevent.spawn(starteachserver(coincontroller, exenames, envars, user.get_pwd(), appdata, startupstatcheckfreqscnds)),
gevent.spawn(enablestake(coincontroller, user.get_pwd())),
])
#continuekey=input('press a key to continue:')
#-server -daemon
#-rpcuser=stakenanny
#rpcallowip=127.0.0.1
#listen=1
#-server
#-daemon=1
#conn = bitcoinrpc.connect_to_local(filename='C:\\Users\\Noe\\AppData\\Roaming\\TurboStake\\turbostake.conf', rpcuser='******', rpcpassword=password)
#conn = bitcoinrpc.connect_to_local(filename='C:\\Users\\Noe\\AppData\\Roaming\\TurboStake\\turbostake.conf')
#best_block_hash = rpc_connection.getbestblockhash()
#print(rpc_connection.getblock(best_block_hash))
#best_block_hash = rpc_connection.getinfo()
#Checking the wallet status every halfsecond would be reasonable
#the connectino error happens at the print line
#info = conn.getinfo()
#print(info)
#blkage = timelapse.BlockAge(1446916630)
#print(str(blkage.age()))
#trans = conn.listtransactions
#print("Blocks: %i" % info.blocks)
#print("Connections: %i" % info.connections)
#for tran in trans(): print("transactoins %s" % tran)
def get(self, table, key):
req = (Atom('get'), Atom(table), key, [], 1000)
result = latency.accum(lambda:self.ebf.rpc('gdss',req))
if result[0] == 'ok':
return serializer.deserialize(result[2])
else:
return Nonez
def load(self):
try:
with open(self.filename, 'r') as file:
self.store = serializer.deserialize(file.read())
except FileNotFoundError:
print_debug_info(f'File not found: {self.filename}')
except EOFError as e:
print_debug_info(f'Error with file: {e}')
def load_key(filename):
""" Attempts to load a key from the provided file.
Args:
filename: Specifies the key file.
"""
with open(filename, 'r') as f:
return serializer.deserialize(f.read())
def update(self, data: dict):
if "data" not in data:
return self.respond_with_error("no data")
new = deserialize(data["data"])
if new is None:
return self.respond_with_error("invalid data")
State.set(new)
self.sync()
def load_chain(self):
if os.path.exists('ddos_bc_file.txt') and \
os.stat('ddos_bc_file.txt').st_size != 0 and \
Path('ddos_bc_file.txt').is_file():
print_debug_info('Load existing blockchain from file')
with open('ddos_bc_file.txt', 'r') as bc_file:
self.chain = serializer.deserialize(bc_file.read())
else:
self.chain[DDosHeader(0, 0, 768894480, 0, 0)] = []
def get_metadata_from_parent(base_url):
try:
resp = requests.get(base_url + SCHEMA_ROUTE,
cert=CLIENT_CERT,
verify=False)
schema = resp.json()
return deserialize(schema["schema"])
except ConnectionError as e:
raise RuntimeError(f"Could not reach parent at {base_url}")
def gets(self, table, key):
req = (Atom('get'), Atom(table), key, [Atom('get_attribs')], 1000)
result = latency.accum(lambda:self.ebf.rpc('gdss',req))
self.timestamp_cache[(table,key)] = result[1]
#print "cached:",self.timestamp_cache[(table,key)]
if result[0] == 'ok':
return serializer.deserialize(result[2])
else:
return None
def get_casedata(path, output_filepath=None, verbose=False, **kwargs):
'''
If path is a serialized casedata file, deserialize it and return it.
If path is file containing valid json-ld, ingest it.
If path is file that is contains something else, raise exception.
If path is a directory or something else, raise exception.
Arguments:
path Full path to a serialized casedata file or a json-ld file
output_filepath If specified and using Ontospy, filepath to save preconditioned file
verbose If true and using Ontospy, Ontospy library runs verbosely
kwargs Additional arguments passed on to Ontospy
Return:
An CaseData object
Raise:
Exception if path is not a serialized casedata file or a valid json-ld file.
'''
# Start with an empty CaseData object
casedata = CaseData()
# If path is not a file, raise
if not os.path.isfile(path):
raise Exception(
'{} is neither a serialized casedata file nor a jsonld file'.
format(path))
# If path is a serialized casedata file, deserialize it and return casedata
try:
identifier, metadata, casedata.__dict__ = serializer.deserialize(path)
if identifier == serializer.CASEDATA:
if metadata['version'] != VERSION:
print(
'{} was serialized with a different version of the toolkit. Use this command to reserialize:'
.format(path))
print()
print(' serialize {}'.format(metadata['path']))
print()
raise Exception(
'{} was serialized with a different version of the toolkit.'
.format(path))
return casedata
except serializer.DeserializeError:
pass
# If it's not a serialized casedata file, assume it contains valid json-ld and ingest it.
try:
casedata.__dict__ = _read_jsonld_file(path, output_filepath, verbose,
**kwargs)
return casedata
except json.decoder.JSONDecodeError as exc:
raise Exception('{} is not a json file.'.format(path)) from exc
# Return the casedata object
return casedata
def unpack_msg(msg: bytes) -> Tuple[str, Any]:
""" Deserialize a message.
Args:
msg: Message to unpack.
Returns:
Unpacked message.
"""
return serializer.deserialize(msg.decode('utf-8'))
def testSerializer():
import serializer
from dfs_state import DFS
bob = (1, 2, 3, 4)
s = serializer.serialize(bob)
obj = serializer.deserialize(s)
print obj
dfs = DFS()
s = serializer.serialize(dfs)
obj = serializer.deserialize(s)
print obj.id
nw = {'a': DFS(), 'b': DFS(), 'c': DFS()}
fs = [1, 2, 3, 4, 5]
state = (fs, nw)
s = serializer.serialize(state)
obj = serializer.deserialize(s)
print obj
def deserialize(self):
"""
Load all collections from disk
@raise CX if there is an error in deserialization
"""
for collection in (
self._settings,
self._distros,
self._repos,
self._profiles,
self._images,
self._systems,
self._mgmtclasses,
):
try:
serializer.deserialize(collection)
except Exception as e:
raise CX("serializer: error loading collection %s: %s. Check /etc/cobbler/modules.conf" % (collection.collection_type(), e))
def rebuild_obj(obj):
""" Help function to serialize and deserialize an object
Args:
obj: Object to (de)serialize
Returns:
New object
"""
s = serialize(obj)
d = deserialize(s)
return d
def get(msg):
"""
Returns the tuple: data, message-type
:param msg:
:return:
"""
d = serializer.deserialize(msg)
return (
d.get('data', {}),
d.get('task', ''),
d.get('type', MESSAGE_TYPE_EMPTY),
)
def loadState(self):
state = self.fileSystem_.readState()
if state:
try:
fs, ns = serializer.deserialize(state)
except Exception, ex:
self.log_.e('found state, but failed to deserialize: ' + str(ex))
return
if len(fs) + len(ns) > 0:
self.log_.i('Loaded ' + str(len(fs)) + ' files and ' + str(len(ns)) + ' device addresses from state')
self.fileSystem_.loadFromState(fs)
self.network_.loadFromState(ns)
def load_chain(self):
""" Loads Blockchain from the hard drive.
"""
if os.path.exists('bc_file.txt') and \
os.stat('bc_file.txt').st_size != 0 and \
Path('bc_file.txt').is_file():
print_debug_info('Load existing blockchain from file')
with open('bc_file.txt', 'r') as bc_file:
self.chain = serializer.deserialize(bc_file.read())
else:
# If file doesn't exist / is empty:
# Create genesis block
self.chain[Header(0, 0, 768894480, 0, 0, 0)] = []
def get_ontology(path, verbose=True, **kwargs):
'''
If path is a serialized ongology file, deserialize it and return it.
If path is a directory that contains turtle files, build Ontology object from scratch.
If path is something else, raise exception.
Arguments:
path Full path to a serialized ontology file or a directory containing turtle files
verbose If true and using Ontospy, Ontospy library runs verbosely
kwargs Additional arguments passed on to Ontospy
Return:
An Ontology object
Raise:
Exception if path is not a serialized ontology file or a directory containing turtle files
'''
# Start with empty Ontology object
ontology = Ontology()
# If path is a serialized ontology file, deserialize it and set context for error messages
if os.path.isfile(path) and serializer.get_identifier(
path) == serializer.ONTOLOGY:
_identifer, metadata, ontology.__dict__ = serializer.deserialize(path)
if metadata['version'] != VERSION:
print(
'{} was serialized with a different version of the toolkit. Use this command to reserialize:'
.format(path))
print()
print(' serialize {}'.format(metadata['path']))
print()
sys.exit(1)
# If path is a directory containing turtle files, build Ontology
# Note that _read_turtle_files sets the context for error messages
elif os.path.isdir(path) and [
filename
for filename in os.listdir(path) if filename.endswith('.ttl')
]:
ontology.__dict__ = _read_turtle_files(path, verbose, **kwargs)
# If path is something else, raise
else:
raise Exception(
'{} is neither a serialized ontology file nor a directory containing turtle files'
.format(path))
# Return the ontology object
return ontology
def get_ontology(path, verbose=True, **kwargs):
'''
If path is a serialized ongology file, deserialize it and return it.
If path is a directory that contains turtle files, build Ontology object from scratch.
If path is something else, raise exception.
Arguments:
path Full path to a serialized ontology file or a directory containing turtle files
verbose If true and using Ontospy, Ontospy library runs verbosely
kwargs Additional arguments passed on to Ontospy
Return:
An Ontology object
Side effect:
This function populates namespace_manager.namespace_manager
Raise:
Exception if path is not a serialized ontology file or a directory containing turtle files
'''
# Start with empty Ontology object
ontology = Ontology()
# If path is a serialized ontology file, deserialize it and populate namespace_manager
if os.path.isfile(path) and serializer.get_identifier(
path) == serializer.ONTOLOGY:
_identifer, _metadata, ontology.__dict__ = serializer.deserialize(path)
namespace_manager.populate(ontology.constraints.keys())
# If path is a directory containing turtle files, build Ontology object AND populate namespace_manager
# Note: _read_turtle_files() populates the namespace_manager so the ontology errors can use it
elif os.path.isdir(path) and [
filename
for filename in os.listdir(path) if filename.endswith('.ttl')
]:
ontology.__dict__ = _read_turtle_files(path, verbose, **kwargs)
# If path is something else, raise
else:
raise Exception(
'{} is neither a serialized ontology file nor a directory containing turtle files'
.format(path))
# Populate the namespace from the ontology classes
# Return the ontology object
return ontology
def list_videos(event, context):
"""
Return list videos
:return:
"""
if "queryStringParameters" in event:
param = event["queryStringParameters"]
if "channelId" in param:
channelId = param["channelId"]
if "pageToken" in param:
start_key = serializer.deserialize(param["pageToken"])
else:
start_key = None
if "limit" in param:
limit = int(param["limit"])
else:
limit = 20
if "fromDate" in param:
from_date = get_time_stamp(param["fromDate"])
else:
from_date = None
if "toDate" in param:
to_date = get_time_stamp(param["toDate"])
else:
to_date = None
from_db = db.list_videos(channelId=channelId,
limit=limit,
startKey=start_key,
fromDate=from_date,
toDate=to_date)
to_client = {"videos": from_db["Items"]}
if "LastEvaluatedKey" in from_db:
next_key = serializer.serialize(from_db["LastEvaluatedKey"])
to_client["nextToken"] = next_key
return wrap_response(to_client)
else:
return wrap_response(None)
def remote_decompress(zipfilename, distdir, host='localhost', port=9999):
# Create a socket (SOCK_STREAM means a TCP socket)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
# Connect to server and send data
sock.connect((host, port))
with open(zipfilename, 'rb') as f:
sock.sendall(f.read())
# Receive data from the server and shut down
received = sock.recv(102400000) # socket接收结束方式待修正
result = deserialize(received)
subfilenum, successnum = len(result), 0
for filename, filebyte in result.items():
if filebyte:
if not os.path.isdir(distdir): os.mkdir(distdir)
with open(os.path.join(distdir, filename), 'wb') as f:
f.write(filebyte)
successnum += 1
status = 2 if successnum == 0 else 0 if subfilenum == successnum else 1
return [status, subfilenum, successnum]
def deserialize(self):
"""
Load the object hierachy from disk, using the filenames referenced in each object.
"""
for item in [
self._settings,
self._distros,
self._repos,
self._profiles,
self._images,
self._systems,
self._mgmtclasses,
self._packages,
self._files,
]:
try:
if not serializer.deserialize(item): raise ""
except:
raise CX("serializer: error loading collection %s. Check /etc/cobbler/modules.conf" % item.collection_type())
return True
def deserialize(self):
"""
Load the object hierachy from disk, using the filenames referenced in each object.
"""
for item in [
self._settings,
self._distros,
self._repos,
self._profiles,
self._images,
self._systems,
self._mgmtclasses,
self._packages,
self._files,
]:
try:
if not serializer.deserialize(item): raise ""
except:
raise CX("serializer: error loading collection %s. Check /etc/cobbler/modules.conf" % item.collection_type())
return True
def parse(self, record):
'''
Parse consumer's record and return a pair of the deserialized data among
with the datetime of the first record.
:param record: A received :class:`kafka.consumer.fetcher.ConsumerRecord` object.
:returns : A pair of the datetime and a list of ``str`` objects.
:rtype : ``tuple``
'''
self._logger.info('Received segment from Kafka cluster. [Topic: {0}, Partition: {1}]'
.format(record.topic, record.partition))
self._logger.debug('[Offset: {0}, Partition: {1}, Checksum: {2}]'
.format(record.offset, record.partition, record.checksum))
try:
return (datetime.utcfromtimestamp(float(record.timestamp) / 1000),
deserialize(record.value))
except Exception as exc:
self._logger.error('[{0}] {1}'.format(exc.__class__.__name__, exc.message))
return None
def get(self, block=True, timeout=None):
smsg = super(SerialQueue, self).get(block=block, timeout=timeout)
return serializer.deserialize(smsg)
def deserialize(self):
"""
Load the object hierachy from disk, using the filenames referenced in each object.
"""
try:
serializer.deserialize(self._settings)
except:
traceback.print_exc()
raise CX("/etc/cobbler/settings is not a valid YAML file")
serializer.deserialize(self._distros)
serializer.deserialize(self._repos)
serializer.deserialize(self._profiles)
serializer.deserialize(self._images)
serializer.deserialize(self._systems)
return True
def deserialize(self):
"""
Load the object hierachy from disk, using the filenames referenced in each object.
"""
try:
serializer.deserialize(self._settings)
except:
traceback.print_exc()
raise CX("/etc/cobbler/settings is not a valid YAML file")
serializer.deserialize(self._distros)
serializer.deserialize(self._repos)
serializer.deserialize(self._profiles)
serializer.deserialize(self._images)
serializer.deserialize(self._systems)
return True
def get(self,block=True,timeout=None):
smsg = super(SerialQueue,self).get(block=block,timeout=timeout)
return serializer.deserialize(smsg)
def __del__(self):
self.socket.close()
def add(self, table, key, value):
value = serializer.serialize(value)
try:
self.client.Add(ttypes.Add(table, key, value))
return True
except Exception, e:
return False
def get(self, table, key):
try:
value = self.client.Get(ttypes.Get(table,key)).value
except Exception, e:
return None
return serializer.deserialize(value)
def gets(self, table, key):
try:
result = self.client.Get(ttypes.Get(table,key))
except Exception, e:
return None
self.timestamp_cache[(table,key)] = result.timestamp
return serializer.deserialize(result.value)
def set(self, table, key, value):
value = serializer.serialize(value)
self.client.Set(ttypes.Set(table, key, value))
def replace(self, table, key, value):
value = serializer.serialize(value)
try:
