예제 #1
0
 def to_dict(string):
   try:
     if not isinstance(string, basestring):
       return loads(str(string))
     return loads(string)
   except:
     raise ValueError('Expected a string or buffer.')
예제 #2
0
파일: certificate.py 프로젝트: fortran95/xi
    def load_private_text(self,filename,pinreader=passphrase_callback):

        log.info("Trying to load a private certificate.")

        try:
            loadsh = serializer.loads(open(filename,'r').read())
            log.info("Load as plain text with no passphrase seems OK.")

        except:
            if pinreader != None:
                try:

                    log.info("Load as encrypted text. Requiring passphrase.")

                    passphrase = pinreader(False)
                    if type(passphrase) != str:
                        raise Exception("User refused passphrase request.")
                    key = self.derive_savekey(passphrase)
                    self.private_save_key = key

                    decryptor = ciphers.xipher(key)
                    shcontent = decryptor.decrypt(open(filename,'r').read())
                    
                    loadsh = serializer.loads(shcontent)
                except Exception,e:
                    log.exception("Unable to decrypt given file: %s",e)
                    raise Exception("Unable to decrypt given file: %s" % e)
            else:
                raise Exception("Unable to load given file.")
예제 #3
0
파일: test_int.py 프로젝트: py-bson/bson
    def test_int(self):
        dump = dumps(self.good_request_dict)
        decoded = loads(dump)
        self.assertEqual(decoded, self.good_request_dict)

        with self.assertRaises(Exception):
            dump = dumps(self.bad_request_dict)
            decoded = loads(dump)
 def read_from_bytestream(cls, buffer_stream, messageLength):
     messageLength -= sizeof(MongoMsgHeader)
     database = read_cstring(buffer_stream)      ;messageLength -= len(database) + 1
     commandName = read_cstring(buffer_stream)   ;messageLength -= len(commandName) + 1
     buffer = buffer_stream.read(messageLength)
     metadata = bson.loads(buffer)
     commandReply = bson.loads(buffer[len(bson.dumps(metadata)):])
     return cls(database, commandName, metadata, commandReply)
    def test_bsonrecorder(self):
        # Verify bson output can be read and that it matches json.
        bson_out = StringIO()
        json_out = StringIO()
        self.top.recorders = [BSONCaseRecorder(bson_out),
                              JSONCaseRecorder(json_out)]
        self.top.run()

        json_run = json.loads(json_out.getvalue())

        inp = StringIO(bson_out.getvalue())
        reclen = unpack('<L', inp.read(4))[0]
        data = inp.read(reclen)
        obj = bson.loads(data)  # simulation_info
        keys = sorted(obj.keys())
        self.assertEqual(keys, sorted(json_run['simulation_info'].keys()))
        for key in keys:
            # graph sometimes serializes with nodes in differant order
            # between json and bson. The graphs are still equivalent, but the
            # assertion below will fail
            if key not in ('uuid', 'graph',):
                self.assertEqual(obj[key], json_run['simulation_info'][key])

        driver_count = 1
        case_count = 1
        data = inp.read(4)
        while data:
            reclen = unpack('<L', data)[0]
            data = inp.read(reclen)
            obj = bson.loads(data)  # driver_info or iteration_case
            keys = sorted(obj.keys())

            if '_driver_id' in obj:  # iteration_case
                case = 'iteration_case_%s' % case_count
                self.assertEqual(keys, sorted(json_run[case].keys()))
                for key in keys:
                    if key not in ('_driver_id', '_id', '_parent_id',
                                   'timestamp'):
                        self.assertEqual(obj[key], json_run[case][key])
                case_count += 1
            else:  # driver_info
                driver = 'driver_info_%s' % driver_count
                self.assertEqual(keys, sorted(json_run[driver].keys()))
                for key in keys:
                    if key not in ('_id',):
                        self.assertEqual(obj[key], json_run[driver][key])
                driver_count += 1

            data = inp.read(4)
예제 #6
0
 def getSignal(self, date=datetime.date.fromtimestamp(time.time()),
               username=False, numpy=False):
     username = self._checkUsername(username)
     if not (type(date) == datetime.date or
             type(date) == datetime.datetime):
         raise Exception('date must be a date or datetime object')
         return False
     r = self.s.get(Beddit.APIBASE+'user/'+username +
                    '/%04d/%02d/%02d/signal.bson' %
                    (date.year, date.month, date.day))
     data = bson.loads(r.content)
     if not data or not numpy:
         return data
     import numpy as np
     import numpy.lib.recfunctions as recfunctions
     data['interval_start'] = datetime.datetime.strptime(
         data['interval_start'], "%Y-%m-%dT%H:%M:%S")
     data['interval_end'] = datetime.datetime.strptime(
         data['interval_end'], "%Y-%m-%dT%H:%M:%S")
     for key in data['channels']:
         for key in data['channels']:
             if 'sample_data' in data['channels'][key]:
                 dataset = data['channels'][key]['sample_data']
                 rate = data['channels'][key]['sample_rate']
                 sample_data = np.fromstring(dataset, np.dtype(
                                             [(str(key), np.int16)]))
                 xaxis = np.linspace(0.0,
                                     float(len(sample_data))/float(rate),
                                     float(len(sample_data)))
                 dataset = recfunctions.append_fields(sample_data,
                                                      'time',
                                                      xaxis,
                                                      usemask=False)
                 data['channels'][key]['sample_data'] = dataset
     return data
예제 #7
0
파일: test_uuid.py 프로젝트: py-bson/bson
    def test_legacy_uuid(self):
        uuid = UUID('584bcd8f-6d81-485a-bac9-629c14b53847')
        serialized = b' \x00\x00\x00\x05uuid\x00\x10\x00\x00\x00\x03XK\xcd\x8fm\x81HZ\xba\xc9b\x9c\x14\xb58G\x00'
        obj = loads(serialized)

        self.assertIsInstance(obj['uuid'], UUID)
        self.assertTrue(obj['uuid'] == uuid)
예제 #8
0
파일: certificate.py 프로젝트: fortran95/xi
    def verify_sign(self,message,sign):
        try:
            if type(sign) == type(""):
                j = serializer.loads(sign)
            else:
                j = sign
            
            keyindex = 1
            for key in self.keys:
                signer = signature.signature(key.get_publickey())
                if j.has_key(keyindex):
                    sig = j[keyindex]
                elif j.has_key(str(keyindex)):
                    sig = j[str(keyindex)]
                else:
                    return False
                if not signer.verify(sig,message):
                    return False
                keyindex += 1
        except Exception,e:

            log.warning("Failed verifying a sign, returning False. More details: %s",e)

            print "Error: %s" % e
            return False
예제 #9
0
파일: master.py 프로젝트: sdobz/loadfrock
    def handle_slave_message(self, msg):
        """
        Slaves send in heartbeats and test results. Handle finding the associated local slave instance and interpreting
        the message.
        :param msg: A bson encoded dict with message data.
            action:   A string representing the action being taken. Must have an associated function on the local slave class
                      with the @action decorator
            slave_id: The id assigned to the slave. If this is not present the slave doesn't have one and should be sent one
            <message specific data>
        """
        # TODO: Think through the security implications of letting slaves report their own ids and uuids
        data = bson.loads(msg)
        if "action" in data:
            # Slaves without a valid slave_id are unregistered and need to be created locally
            # TODO: Move slave creation into load_slave
            if "slave_id" not in data or data["slave_id"] not in self.slave_registry:
                if data["action"] == "heartbeat":
                    # Heartbeats are typically the way slaves are discovered
                    slave = self.new_slave(data)
                    # TODO: handle slave creation failure
                else:
                    log.error("Got non-heartbeat message from unknown slave")
                    return
            else:
                # Load the local instance
                slave = self.load_slave(data)
                # TODO: handle save loading failure

            assert slave
            # run_action looks up the @action method on the slave and runs it with data
            slave.run_action(data)
예제 #10
0
    def data_received(self, data: ByteString):
        # Expected format: bson_encoding( {"channels": [List_of_channels], "message": message} )
        # Example: bson.dumps({"channels": ["global"], "message": "Hello, world\nMultiline!"})
        # Meaning: Send "Hello, world\nMultiline!" to channel "global", the sender gets identified by his socket.
        # The first 4 byte specify the length of BSON document and will be used as a splitting mark.
        # One attempt is made to decode the resulting object. Failure to decode discards the object.
        # This sadly means if we ever loose sync to a client (can not happen incidentally with TCP/TLS)
        # there is no way to decode further transmissions.
        # TODO: Examine further handling in this case, maybe drop the connection since it's either an incompatible
        # encoding or a malicious attempt.
        logging.debug("Got raw data[{}] {!r} from {}".format(len(data), data, self.peername))
        self.buffer.extend(data)
        logging.debug("Buffer of {} contains {!r}".format(self.peername, self.buffer))

        # TODO: maybe use memoryview to prevent useless copies on every slicing operation
        if len(self.buffer) >= 4:
            bson_expected_len = unpack("<i", self.buffer[:4])[0]
            if len(self.buffer) >= bson_expected_len:
                bson_obj = self.buffer[:bson_expected_len]  # contains the (hopefully) valid BSON object
                self.buffer = self.buffer[bson_expected_len:]  # shifts the buffer to the start of the next object
                try:
                    t = time.clock()
                    message = bson.loads(bson_obj)
                    delta = time.clock() - t
                    logging.debug("Decoded {} from {}, took {} s".format(message, self.peername, delta))
                    asyncio.ensure_future(self.chat.add_message(self, message))
                except IndexError as e:
                    logging.warning("{}: BSONDecodeError: {}".format(self.peername, e))
                    pass
예제 #11
0
 def _next(self):
     """ Return next dictionary of data. """
     data = self._inp.read(4)
     if not data:
         return None
     reclen = unpack('<L', data)[0]
     return bson.loads(self._inp.read(reclen))
예제 #12
0
    def test_unknown_handler(self):
        d = Decimal("123.45")
        obj = {"decimal": d}

        serialized = dumps(obj, on_unknown=float)
        unserialized = loads(serialized)
        self.assertEqual(float(d), unserialized["decimal"])
예제 #13
0
    def __init__(self,keystr):
        try:
            if type(keystr) == str:
                j = serializer.loads(keystr)
            else:
                j = keystr

            if j['type'] == 'RSA_Public_Key':
                self.key = _RSA()
                self.is_private_key = False
            elif j['type'] == 'EC_Public_Key':
                self.key = _EC()
                self.is_private_key = False
            elif j['type'] == 'RSA_Private_Key':
                self.key = _RSA()
                self.is_private_key = True
            elif j['type'] == 'EC_Private_Key':
                self.key = _EC()
                self.is_private_key = True
            else:
                raise Exception("Unrecognized type of public key.")
            
            keystr = serializer.dumps(j)

            if self.is_private_key:
                self.key.load_privatekey(keystr)
            else:
                self.key.load_publickey(keystr)
        except Exception,e:
            raise Exception("Failed initilizing PublicKeyAlgorithm: %s" % e)
 def _get_ordered_queue_owners_dict(self):
     #return self._qm_redis_client.hgetall("oq_owners")
     dumped_ordered_queue_owners_dict = self._qm_redis_client.get("oq_owners")
     if dumped_ordered_queue_owners_dict == None:
         return None
     
     return bson.loads(dumped_ordered_queue_owners_dict)
예제 #15
0
  def receivedData(self, received):
    '''Receive int prefixed data until full bson doc.'''

    self.recv_buffer += received

    while len(self.recv_buffer) >= self.length_size:
      length ,= struct.unpack(
        self.length_fmt, self.recv_buffer[:self.length_size])

      if length > self.max_bytes:
        self.lengthLimitExceeded(length)
        return # bad news bears.

      if len(self.recv_buffer) < length:
        break # not enough for full bson doc yet.

      bsonData = self.recv_buffer[:length]
      self.recv_buffer = self.recv_buffer[length:]

      try:
        bsonDoc = bson.loads(bsonData)
      except Exception, e:
        e.bsonData = bsonData
        self.bsonDecodingError(e)
        # Note: at this point, we may be off sync (warranting disconnect)
        #       but let's attempt to keep going!
      else:
        self.receivedBson(bsonDoc)
        gevent.sleep(0) # cooperative yield. we got a document (a unit of work)
예제 #16
0
파일: certificate.py 프로젝트: fortran95/xi
    def load_signature(self,sign): 
        # 对于私或公用证书均可,加载一个签名信息,可能是签名或签名撤回信息
        try:
            if type(sign) == type(""):
                j = serializer.loads(sign)
            else:
                j = sign

            sig   = j['Signature']
            c     = j['Content']
            chash = self.signature_hash(j)

            if not self.check_signature_content(c,loading=True):
                raise Exception("This signature cannot be loaded. Either it is of invalid format, or it is not for this certificate.")
            log.info('Signature loaded.')

            for s in self.signatures:
                if self.signature_hash(s) == chash:
                    log.warning('This signature has already been loaded.')
                    return

            self.signatures.append(j)
        except Exception,e:

            log.warning('Cannot load the signature. Details: %s',e)

            raise Exception("Error loading a signature: %s" % e)
예제 #17
0
    def load(self,inp):
        self.textbox.delete(1.0,END)
        j = bson.loads(inp)
        plaintext = zlib.decompress(j['t'])

        stripped = self._stripText(plaintext)
        def r(x,r=stripped[1],c=stripped[2]):
            nr = x[0] - r
            if nr == 1:
                return "%d.%d" % (nr,x[1]-c)
            else:
                return "%d.%d" % (nr,x[1])

        decorations = j['d']
        self.textbox.insert(END,stripped[0])
        for tagname,indexlist in decorations.items():
            while indexlist:
                if len(indexlist) >= 2:
                    cstart,cend = [r(t) for t in indexlist[0:2]]
                    indexlist = indexlist[2:]
                else:
                    cstart = r(indexlist[0])
                    cend = END
                    indexlist = []
                self.textbox.tag_add("tag%d" % int(tagname),cstart,cend)
예제 #18
0
파일: common.py 프로젝트: fycheung/misc
def decodePacket_bson(packet):
    """解包"""
    try:
        packet = StringIO(packet)
        fp = gzip.GzipFile(mode='rb', fileobj=packet)
        packet = fp.read()
        fp.close()
        recv_data = bson.loads(packet)
        
        assert isinstance(recv_data, dict), 'recv_data should be a dict'

        optId = int(recv_data['opt_id'])
        optKey = recv_data['opt_key']
        
        if not isinstance(recv_data.get('para'), dict):
            para = {}
        else:
            para = recv_data['para']

        if 'stime' in recv_data:
            #此处校验客户端与服务器时间
            # + todo
            para['ClientTime'] = int(recv_data['stime'])
        else:
            para['ClientTime'] = int(time.time())

        return optId, optKey, para
    except Exception, e:
        print 'decodePacket 异常!无法解压数据 > ', e, packet 
        return False
예제 #19
0
	def test_random_tree(self):
		for i in xrange(0, 16):
			p = {}
			populate(p, 256, 4)
			sp = dumps(p)
			p2 = loads(sp)
			self.assertEquals(p, p2)
예제 #20
0
    def test_decimal(self):
        decimal = Decimal('1234.45')
        obj = {"decimal": decimal}
        serialized = dumps(obj)
        obj2 = loads(serialized)

        self.assertIsInstance(obj2['decimal'], float)
        self.assertTrue(obj2['decimal'] == float(decimal))
예제 #21
0
 def __call__(self, *args):
     postdata = dumps({"method": self.__serviceName, "params": args, "id": "jsonrpc"})
     respdata = urllib.urlopen(self.__serviceURL, postdata).read()
     resp = loads(respdata)
     if resp["error"] != None:
         raise JSONRPCException(resp["error"])
     else:
         return resp["result"]
 def read_from_bytestream(cls, buffer_stream, messageLength):
     messageLength -= sizeof(MongoMsgHeader)
     flags = c_int.from_buffer_copy(buffer_stream.read(sizeof(c_int))).value             ;messageLength -= sizeof(c_int)
     fullCollectionName = read_cstring(buffer_stream)                                    ;messageLength -= len(fullCollectionName) + 1
     numberToSkip = c_int.from_buffer_copy(buffer_stream.read(sizeof(c_int))).value      ;messageLength -= sizeof(c_int)
     numberToReturn = c_int.from_buffer_copy(buffer_stream.read(sizeof(c_int))).value    ;messageLength -= sizeof(c_int)
     query = bson.loads(buffer_stream.read(messageLength))
     return cls(flags, fullCollectionName, numberToSkip, numberToReturn, query)
예제 #23
0
파일: s_object.py 프로젝트: ilius/starcal
def loadBsonObject(_hash):
	fpath = join(objectDir, _hash[:2], _hash[2:])
	bsonBytes = open(fpath, "rb").read()
	if _hash != sha1(bsonBytes).hexdigest():
		raise IOError(
			"sha1 diggest does not match for object file \"%s\"" % fpath
		)
	return bson.loads(bsonBytes)
예제 #24
0
파일: test_uuid.py 프로젝트: py-bson/bson
    def test_uuid(self):
        uuid = UUID('584bcd8f-6d81-485a-bac9-629c14b53847')
        obj = {"uuid": uuid}
        serialized = dumps(obj)
        obj2 = loads(serialized)

        self.assertIsInstance(obj2['uuid'], UUID)
        self.assertTrue(obj2['uuid'] == uuid)
예제 #25
0
    def test_false_value(self):
        data = {"key": False}
        serialized = bson.dumps(data)
        deserialized = bson.loads(serialized)

        self.assertIsInstance(deserialized["key"], bool)
        self.assertFalse(deserialized["key"])
        self.assertTrue(serialized == b'\x0b\x00\x00\x00\x08key\x00\x00\x00')
 def create_from_received(raw_message, qm_dealer_id_tag):
     """
     Returns a new message of this type from the raw message data.
     """
     
     try:
         return PeerOnlineHandshakeRequestMessage(bson.loads(raw_message[1]), raw_message[2], qm_dealer_id_tag)
     except:
         raise ExceptionFormatter.get_full_exception()
예제 #27
0
파일: tpt.py 프로젝트: jacob1/jacobot
def GetSaveData(ID):
	compressedsave = open("saves/{0}.cps".format(ID), "rb")
	compressedsave.seek(12)
	save = bz2.decompress(compressedsave.read())
	try:
		data = bson.loads(save)
	except ValueError:
		return None
	return data
 def create_from_received(raw_message, sender_id_string):
     """
     Returns a new message of this type from the raw message data.
     """
     
     try:
         return PeerForwardedCommandMessage(None, bson.loads(raw_message[1]), sender_id_string)
     except:
         raise ExceptionFormatter.get_full_exception()
예제 #29
0
    def test_datetime(self):
        now = datetime.now(pytz.utc)
        obj = {"now" : now}
        serialized = dumps(obj)
        obj2 = loads(serialized)

        td = obj2["now"] - now
        seconds_delta = (td.microseconds + (td.seconds + td.days * 24 * 3600) *
                1e6) / 1e6
        self.assertTrue(abs(seconds_delta) < 0.001)
    def load(dumped_string):
        """
        Returns an instance object of this class built from string which was created in the "dump" method.
        """

        dumped_string = cast_bytes(dumped_string)
        loaded_dictionary = bson.loads(dumped_string)
        exchange_wrapper = ExchangeWrapper("", "")
        exchange_wrapper.__dict__.update(loaded_dictionary)
        return exchange_wrapper
예제 #31
0
def decode_bson_val(bts):
    d = bson.loads(bts)
    revision, item_val = d['e']
    return revision, item_val
예제 #32
0
def bson_loads(s):
    return bson.loads(s)
예제 #33
0
def message_to_pose(message):
    pose_message = bson.loads(message.payload)
    return [pose_message['timestamp']] + list(map(lambda k: pose_message['data']['position'][k], ['x', 'y', 'z'])) +\
           list(map(lambda k: pose_message['data']['rotation'][k], ['w', 'x', 'y', 'z']))
예제 #34
0
 def test_long_array(self):
     serialized = dumps(self.doc)
     doc2 = loads(serialized)
     self.assertEquals(self.doc, doc2)
예제 #35
0
파일: Bison.py 프로젝트: Tweak161/fa2909
 def read_bson(self, filename):
     f = open(filename, "rb")
     bson_data = f.read()
     message_dict = bson.loads(bson_data)
     print(message_dict)
예제 #36
0
파일: training.py 프로젝트: alyxb/bubbles
def read_users():
    chatusers = open('foundry/chatusers.bson', 'rb').read()
    return bson.loads(chatusers.read())
예제 #37
0
 def test_int_as_key(self):
     dump = dumps(self.test_dict)
     decoded = loads(dump)
     dumpByJson = json.dumps(self.test_dict)
     decodedByJson = json.loads(dumpByJson)
     self.assertEqual(decoded, decodedByJson)
예제 #38
0
# import simplejson as serializer
import bson as serializer
import zmq
import sys

context = zmq.Context()
receiver = context.socket(zmq.SUB)
receiver.connect("tcp://127.0.0.1:6015")
receiver.setsockopt(zmq.SUBSCRIBE, '')

while True:
    s = serializer.loads(receiver.recv())
    sys.stdout.write(str(s) + '\n')
    sys.stdout.flush()
예제 #39
0
 def deserialize(self, stream):
     return bson.loads(stream.read())
예제 #40
0
파일: test.py 프로젝트: BetaS/gotham-v2
#encoding: utf-8

import bson

origin = {'a': 1}
print origin

data = bson.dumps(origin)
print data

data = bson.loads(data)
print data['a']
예제 #41
0
 def _load_superblocks(self):
     raw_data = self.disk.read(1024 * 1024)
     return OrderedDict(bson.loads(raw_data)['superblocks'])
예제 #42
0
import sys

import bson

b = bson.loads(open(sys.argv[1], 'rb').read())
print(b)
예제 #43
0
def decode_bson(bts: bytes):
    d = bson.loads(bts)
    remap_d = remap_keys_decode(d)
    return remap_d
예제 #44
0
파일: training.py 프로젝트: alyxb/bubbles
def read_prefernces():
    preferences = open('foundry/preferencesfile.bson', 'rb').read()
    return bson.loads(preferences.read())
    def process_server_msg(self, ws, raw_data):
        global _print_event_tracker

        try:
            # raw_data can be both json or bson
            # no py2 compat way to properly detect type here
            # (w/o patching ws lib)
            try:
                msg = json.loads(raw_data)
                _logger.debug('Received: ' + raw_data)
            except ValueError:
                msg = bson.loads(raw_data)
                _logger.debug(
                    'received binary message ({} bytes)'.format(len(raw_data)))

            for command in msg.get('commands', []):
                if command["cmd"] == "pause":
                    self.commander.prepare_to_pause(
                        self._printer, **command.get('args'))
                    self._printer.pause_print()

                if command["cmd"] == 'cancel':
                    self._printer.cancel_print()

                if command["cmd"] == 'resume':
                    self._printer.resume_print()

                if command["cmd"] == 'print':
                    self.start_print(**command.get('args'))

            passsthru = msg.get('passthru')
            if passsthru:
                target = getattr(self, passsthru.get('target'))
                func = getattr(target, passsthru['func'], None)
                if not func:
                    return

                ack_ref = passsthru.get('ref')
                ret = func(*(passsthru.get("args", [])))

                if ack_ref:
                    self.send_ws_msg_to_server({'passthru': {'ref': ack_ref, 'ret': ret}})

                time.sleep(0.2)  # chnages, such as setting temp will take a bit of time to be reflected in the status. wait for it
                self.post_printer_status(_print_event_tracker.octoprint_data(self))

            if msg.get('janus') and self.webcam_streamer:
                self.webcam_streamer.pass_to_janus(msg.get('janus'))

            if msg.get('remote_status'):
                self.remote_status.update(msg.get('remote_status'))
                if self.remote_status['viewing']:
                    self.jpeg_poster.post_jpeg_if_needed(force=True)

            if msg.get('http.tunnel') and self.local_tunnel:
                self.local_tunnel.send_http_to_local(**msg.get('http.tunnel'))

            if msg.get('ws.tunnel') and self.local_tunnel:
                kwargs = msg.get('ws.tunnel')
                kwargs['type_'] = kwargs.pop('type')
                self.local_tunnel.send_ws_to_local(**kwargs)
        except:
            self.sentry.captureException(tags=get_tags())
예제 #46
0
PAYLOADS = (
    # OP_QUERY: {'flags': 0, 'fullCollectionName': b'admin.$cmd', 'numberToSkip': 0, 'numberToReturn': 1, 'query': {'isMaster': 1, 'client': {'application': {'name': 'MongoDB Shell'}, 'driver': {'name': 'MongoDB Internal Client', 'version': '3.4.4'}, 'os': {'type': 'Windows'$ 'name': 'Microsoft Windows 8', 'architecture': 'x86_64', 'version': '6.2 (build 9200)'}}}}
    b'#\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x07\x00\x00\x00\x00\x00\x00admin.$cmd\x00\x00\x00\x00\x00\x01\x00\x00\x00\xfc\x00\x00\x00\x10isMaster\x00\x01\x00\x00\x00\x03client\x00\xe1\x00\x00\x00\x03application\x00\x1d\x00\x00\x00\x02name\x00\x0e\x00\x00\x00MongoDB Shell\x00\x00\x03driver\x00:\x00\x00\x00\x02name\x00\x18\x00\x00\x00MongoDB Internal Client\x00\x02version\x00\x06\x00\x00\x003.4.4\x00\x00\x03os\x00l\x00\x00\x00\x02type\x00\x08\x00\x00\x00Windows\x00\x02name\x00\x14\x00\x00\x00Microsoft Windows 8\x00\x02architecture\x00\x07\x00\x00\x00x86_64\x00\x02version\x00\x11\x00\x00\x006.2 (build 9200)\x00\x00\x00\x00',
    # OP_COMMAND: {'database': b'admin', 'commandName': b'whatsmyuri', 'metadata': {'whatsmyuri': 1}, 'commandReply': {}}
    b';\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\xda\x07\x00\x00admin\x00whatsmyuri\x00\x15\x00\x00\x00\x10whatsmyuri\x00\x01\x00\x00\x00\x00\x05\x00\x00\x00\x00',
    # OP_COMMAND: {'database': b'admin', 'commandName': b'buildinfo', 'metadata': {'buildinfo': 1.0}, 'commandReply': {}}
    b'=\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\xda\x07\x00\x00admin\x00buildinfo\x00\x18\x00\x00\x00\x01buildinfo\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x05\x00\x00\x00\x00',
    # OP_COMMAND: {'database': b'test', 'commandName': b'isMaster', 'metadata': {'isMaster': 1.0, 'forShell': 1.0}, 'commandReply': {}}
    b'L\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\xda\x07\x00\x00test\x00isMaster\x00)\x00\x00\x00\x01isMaster\x00\x00\x00\x00\x00\x00\x00\xf0?\x01forShell\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x05\x00\x00\x00\x00',
    # OP_COMMAND: {'database': b'admin', 'commandName': b'replSetGetStatus', 'metadata': {'replSetGetStatus': 1.0, 'forShell': 1.0}, 'commandReply': {}}
    b']\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\xda\x07\x00\x00admin\x00replSetGetStatus\x001\x00\x00\x00\x01replSetGetStatus\x00\x00\x00\x00\x00\x00\x00\xf0?\x01forShell\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x05\x00\x00\x00\x00',
)

tcp_connection = socket.create_connection((sys.argv[1], int(sys.argv[2])))
payload_index = int(sys.argv[3]) if len(sys.argv) > 3 else 1
tcp_connection.sendall(PAYLOADS[payload_index])
print('Payload sent')
msg_header = tcp_connection.recv(
    16
)  # reading MsgHeader, cf. https://docs.mongodb.com/manual/reference/mongodb-wire-protocol/#standard-message-header
if not msg_header:
    raise RuntimeError('No response from server')
messageLength = c_int.from_buffer_copy(msg_header[:4]).value
resp = tcp_connection.recv(messageLength - 16)
print('SUCCESS!')
try:
    import bson
    print(bson.loads(resp[20:] if payload_index == 0 else resp))
except ImportError:
    print(resp)
예제 #47
0
 def body(self):
     return bson.loads(self._packet_body)
예제 #48
0
 def recvMessage(self, raw=False):
     if raw:
         message = super(BsonMessages, self).recvMessage()
     else:
         message = bson.loads(super(BsonMessages, self).recvMessage())
     return message
예제 #49
0
import bson


def printTree(node, level):
    if node is not None:
        format = level * "       "
        format += "---[ "
        level += 1
        printTree(node["left"], level)
        print(format + str(node["value"]))
        printTree(node["right"], level)
    pass


with open("tree.bson", "rb") as fin:
    content = fin.read()
    binary_tree = bson.loads(content)
    printTree(binary_tree["root"], 0)
 def ParseFromString(self, str_value):
     self.ParseFromDict(bson.loads(str_value))
# 操作速度
#   bson>json。比如,遍历查找:json需要扫字符串,而bson可以直接定位

# 修改:
#   json也要大动大移,bson就不需要。

# gswewf@gswewf-PC:~$ sudo pip3 install bson

import bson

with open(
        '/home/gswewf/docker/mongo/data/mongodb_192_168_3_130/page/保险条款.bson',
        'rb') as f:
    b_data = f.read()

data = bson.loads(b_data)
type(data)
# Out[5]: dict
list(data.keys())[:3]
# Out[6]: ['_id', 'content', '保险小类']
type(data.get('保险小类'))
# Out[7]: str


def main():
    pass


if __name__ == '__main__':
    main()
예제 #52
0
 def get_encoded_image(self, path):
     with open(path, 'rb') as f:
         return image.fromDict(bson.loads(f.read()))
예제 #53
0
    def run(self):
        running = True
        clock = pygame.time.Clock()
        tickspeed = 60
        last_direction = None
        self.toMove = False  # Flag for when player moves - reduces network stress
        self.cast = False  # Flag for when player casts spell.
        self.status_time = 0
        me = self.players.me
        inputHandler = InputHandler(
        )  #Handles the inputs. They can get stage fright sometimes.
        self.menu_setup()
        self.state = "menu"
        self.menu_current = self.menu_main

        if me.mute == "False":
            LevelMusic.play_music_repeat()

        try:
            while running:
                self.screen.fill(colours["white"])
                clock.tick(tickspeed)

                if self.state == "menu":
                    #This means we're in the menus.
                    action = None
                    for event in pygame.event.get():
                        if event.type == pygame.QUIT or event.type == pygame.locals.QUIT:
                            running = False
                            break
                        if type(self.menu_current) is MenuInput:
                            action = self.menu_current.update(
                                inputHandler, event)
                    if type(self.menu_current) is MenuInput:
                        self.menu_current.render()
                    else:
                        action = self.menu_current.update(inputHandler)
                    if type(action) is Menu or type(action) is MenuInput:
                        self.menu_current = action
                    else:
                        if action == "help":
                            webbrowser.open_new_tab(
                                "https://github.com/neontribe/untangled-2017/wiki"
                            )
                        elif action == "mute":
                            if me.mute == "False":
                                me.set_mute("True", True)
                                LevelMusic.stop_music()
                            elif me.mute == "True":
                                me.set_mute("False", True)
                                LevelMusic.play_music_repeat()
                        elif action == "quit":
                            running = False
                            break
                        elif action == "play_ctf":
                            self.state = "game_ctf"
                        elif action == "rejoy":
                            inputHandler.reloadJoysticks()
                        elif action == "input_name":
                            self.players.me.set_name(
                                self.menu_current.char_name, True)
                            if self.menu_current.parent:
                                self.menu_current = self.menu_current.parent

                elif self.state == "game_ctf":  #There may only be one game at the moment, but this makes it easier to add different game types in the future.
                    #This means we have to actually run the game.
                    if last_direction == None:
                        last_direction = Movement.DOWN
                    for event in pygame.event.get():
                        if event.type == pygame.QUIT or event.type == pygame.locals.QUIT:
                            running = False
                            break
                    if not inputHandler.inputsTimeout["change"]:
                        inputHandler.setTimeout("change", 0.5)
                        inputHandler.setTimeout("enter", 0.5)
                        inputHandler.setTimeout("special", 10)
                        inputHandler.setTimeout("move", move_delay)
                    if inputHandler.checkPress("start"):
                        self.state = "menu"  #Temporary workaround until a proper pause menu is added (or possibly not if this works fine).
                    elif inputHandler.checkHold("up"):
                        me.move(Movement.UP)
                        last_direction = Movement.UP
                        self.toMove = True
                    elif inputHandler.checkHold("down"):
                        me.move(Movement.DOWN)
                        last_direction = Movement.DOWN
                        self.toMove = True
                    elif inputHandler.checkHold("left"):
                        me.move(Movement.LEFT)
                        last_direction = Movement.LEFT
                        self.toMove = True
                    elif inputHandler.checkHold("right"):
                        me.move(Movement.RIGHT)
                        last_direction = Movement.RIGHT
                        self.toMove = True
                    elif inputHandler.checkPress("change"):
                        me.change_spell()
                    elif inputHandler.checkHold("enter"):
                        self.cast = me.attack(last_direction)
                    elif inputHandler.checkHold("special"):
                        me.step = 2
                        me.steptime = time.time()

                    if me.map.level.get_tile(me.x, me.y).has_attribute(
                            TileAttribute.SWIM):
                        inputHandler.setTimeout("move", 0.4)
                    elif me.map.level.get_tile(me.x, me.y).has_attribute(
                            TileAttribute.SLOW):
                        inputHandler.setTimeout("move", 0.2)
                    else:
                        inputHandler.setTimeout("move", move_delay)

                    if time.time() - me.steptime > 3:
                        me.step = 1

                    self.map.render()
                    for flag in self.flags.values():
                        flag.render()

                    me.render(True)

                    for spell in me.cast_spells:
                        spell.render()

                    self.players.set(self.network.node.peers())

                    # check network
                    events = self.network.get_events()
                    if events:
                        try:
                            for event in self.network.get_events():
                                if event.type == 'ENTER':
                                    # Force update on first join.
                                    self.toMove = True

                                    auth_status = event.headers.get(
                                        'AUTHORITY')
                                    if auth_status == 'TRUE':
                                        self.players.authority_uuid = str(
                                            event.peer_uuid)
                                        self.network.authority_uuid = str(
                                            event.peer_uuid)
                                        self.players.remove(event.peer_uuid)
                                elif event.type == "SHOUT":
                                    if event.group == "player:name":
                                        new_name = bson.loads(event.msg[0])
                                        player = self.players.get(
                                            event.peer_uuid)
                                        if new_name['name']:
                                            player.set_name(new_name['name'])
                                    elif event.group == "world:position":
                                        new_position = bson.loads(event.msg[0])
                                        network_player = self.players.get(
                                            event.peer_uuid)
                                        network_player.set_position(
                                            Position(**new_position))
                                    elif event.group == "world:combat":
                                        new_spell_properties = bson.loads(
                                            event.msg[0])
                                        network_spell_caster = self.players.get(
                                            event.peer_uuid)
                                        network_spell_caster.current_spell = new_spell_properties.get(
                                            'current_spell')
                                        network_spell_caster.cast_spells.append(
                                            Spell(
                                                network_spell_caster, (0, 0),
                                                projectile_images[
                                                    network_spell_caster.
                                                    current_spell]))
                                        network_spell_caster.cast_spells[
                                            -1].set_properties(
                                                SpellProperties(
                                                    **new_spell_properties))
                                    elif event.group == "ctf:teams":
                                        team_defs = bson.loads(event.msg[0])
                                        self.players.set_teams(team_defs)
                                    elif event.group == "ctf:gotflag":
                                        flag_info = bson.loads(event.msg[0])
                                        team = flag_info["team"]
                                        uuid = flag_info["uuid"]
                                        flag = self.flags[team]
                                        if uuid == str(
                                                self.network.node.uuid()):
                                            flag.set_player(self.players.me)
                                        else:
                                            network_player = self.players.get(
                                                uuid)
                                            flag.set_player(network_player)
                                    elif event.group == 'ctf:dropflag':
                                        flag_info = bson.loads(event.msg[0])
                                        flag = self.flags[flag_info['team']]
                                        flag.set_player(None)
                                        flag.set_position(
                                            (flag_info['x'], flag_info['y']))
                                    elif event.group == "players:whois":
                                        self.network.node.shout(
                                            "player:name",
                                            bson.dumps(
                                                {"name":
                                                 self.players.me.name}))
                                    elif event.group == "ctf:status":
                                        msg = bson.loads(event.msg[0])
                                        status = msg['status']
                                        self.status_message = status
                                        self.status_time = time.time()
                                    elif event.group == "ctf:scores":
                                        scores = bson.loads(event.msg[0])
                                        self.scores = scores
                                elif event.type == 'WHISPER':
                                    msg = bson.loads(event.msg[0])
                                    if self.players.authority_uuid == str(
                                            event.peer_uuid):
                                        if msg['type'] == 'teleport':
                                            me.set_position(
                                                (msg['x'], msg['y']))
                                            self.toMove = True
                                        elif msg['type'] == 'die':
                                            me.die()

                        except Exception as e:
                            import traceback
                            # traceback.print_exc()
                            pass

                    # if there are other peers we can start sending to groups.
                    if self.toMove == True:
                        self.network.node.shout(
                            "world:position",
                            bson.dumps(me.get_position()._asdict()))
                        self.toMove = False
                    if self.cast == True:
                        try:
                            self.network.node.shout(
                                "world:combat",
                                bson.dumps(me.cast_spells[-1].get_properties().
                                           _asdict()))
                        except:
                            print(error_message + ": me.cast_spells is empty")
                        self.cast = False

                    for playerUUID, player in self.players.others.items():
                        try:
                            player.render()

                            for spell in player.cast_spells:
                                spell.render()
                                hit_me = spell.hit_target_player(me)
                                if hit_me:
                                    player.cast_spells.remove(spell)
                                    me.deplete_health(spell.damage)

                        except PlayerException as e:
                            # PlayerException due to no initial position being set for that player
                            pass

                    score_shift = 220
                    for team, score in self.scores.items():
                        colour = colours[team]
                        display_rect = Rect((score_shift, 0), (200, 75))

                        typeface = fonts['large']
                        score_text = typeface.render(str(score), False,
                                                     colours["white"])

                        text_bounds = score_text.get_rect()
                        text_bounds.center = display_rect.center

                        pygame.draw.rect(self.screen, colour, display_rect)
                        self.screen.blit(score_text, text_bounds.topleft)

                        score_shift += 200

                    if time.time() - self.status_time < 5:
                        typeface = fonts['large']
                        status_text = typeface.render(self.status_message,
                                                      False, colours["white"])
                        text_bounds = status_text.get_rect()
                        text_bounds.center = self.screen.get_rect().center
                        pygame.draw.rect(self.screen, colours["black"],
                                         text_bounds)
                        self.screen.blit(status_text, text_bounds.topleft)

                    self.players.minimap_render(self.screen)

                pygame.display.update()
        finally:
            self.network.stop()
예제 #54
0
 def test_non_utf8_binary(self):
     dump = dumps(self.doc)
     decoded = loads(dump)
     self.assertEqual(decoded, self.doc)
예제 #55
0
파일: train.py 프로젝트: siku2/InScripts
def input_evaluation(matches):
    data = []
    for match in matches:
        data.append((
            {
                "blue": match["blue"],
                "red": match["red"]
            },
            tf.constant(match["winner"])
        ))
    return data


with open("matches.bson", "rb") as f:
    raw_matches = bson.loads(f.read())["matches"]

matches = input_evaluation(raw_matches[:10])

feature_columns = [
    tf.feature_column.indicator_column(tf.feature_column.categorical_column_with_hash_bucket(key="blue", hash_bucket_size=9000)),
    tf.feature_column.indicator_column(tf.feature_column.categorical_column_with_hash_bucket(key="red", hash_bucket_size=9000))
]
hidden_layers = 10 * [len(matches)]
classifier = tf.estimator.DNNClassifier(feature_columns=feature_columns, hidden_units=hidden_layers, n_classes=2)


def train_data():
    dataset = tf.data.Dataset.from_tensor_slices(matches)
    dataset = dataset.shuffle(1000).repeat().batch(100)
    return dataset.make_one_shot_iterator().get_next()
예제 #56
0
from pathlib import Path

import bson
from prodict import Prodict

from main.updater import Updater

model_json = Path("model.json").read_bytes()
model = Prodict.from_dict(bson.loads(model_json))

Updater(model).update_all()
예제 #57
0
def echo(socket, address):

    printl('New connection from %s:%s' % address)
    (ip, port) = address
    data = None
    try:
        data = myreceive(socket)
        if data is None:
            return
        client_param = bson.loads(data)
    except:
        save_bad_request(ip, port, data, dump_dir)
        socket.close
        return

    #{u'imei': 1, u'ts': 23}
    #add new clients to clients list
    incoming_imei = "%s", client_param['imei']
    if not clients.has_key(client_param['imei']):
        printl("adding new client ", client_param['imei'])
        clients[client_param['imei']] = {'lts': 0, 'ltf': 0, 'ts_trial': 0}
    else:
        printl("client already present", client_param['imei'])

    printl("read: %s" % client_param)
    if not client_param:
        printl("client disconnected")
        return
        # [ ts:long,frag:int,type:int,payload:b]

    #check if there are more fragment to sent
    #if (clients[client_param['imei']]['lts'] == client_param['ts'] and clients[client_param['imei']]['ltf'] != 0) and  next_news:
    next_news = echo.next_news

    if echo.fragment > 0:
        if client_param['lts_status'] != "0":
            printl("Failed to Send fragment %d for file %s trials %s/%s" %
                   (echo.fragment, next_news['filepath'],
                    clients[client_param['imei']]['ts_trial'],
                    next_news['trials']))
            if next_news['trials'].isdigit() and int(
                    next_news['trials']) >= int(
                        clients[client_param['imei']]['ts_trial']):
                printl("try again")
                echo.fragment += 1
            else:
                printl("no mor trial")
                clients[client_param['imei']]['lts'] = int(
                    clients[client_param['imei']]['lts']) + 1
                echo.fragment = 0

    if echo.fragment == 0:
        echo.next_news = get_next_news(client_param,
                                       clients[client_param['imei']])
        next_news = echo.next_news
        if next_news and client_param['lts_status'] != '-3':
            echo.file_list = None
            printl("ready to send another news")
            clients[client_param['imei']]['lts'] = next_news['date']
            if os.path.isabs(next_news['filepath']):
                file = dumpImage(next_news['filepath'])
            else:
                file = dumpImage(
                    os.path.dirname(os.path.realpath(__file__)) + "/" +
                    next_news['filepath'])
            if file:
                printl("image is valid")
                echo.file_list = chunkstring(file, echo.fragmentSize)
                echo.fragment = len(echo.file_list)
                clients[client_param['imei']]['ltf'] = echo.fragment

    if echo.file_list is not None and next_news and echo.fragment > 0:

        sha1 = hashlib.sha1(echo.file_list[echo.fragment - 1]).hexdigest()
        repl = bson.dumps({
            "ts": long(next_news['date']),
            "frag": echo.fragment - 1,
            "type": int(next_news['type']),
            "headline": next_news['headline'],
            "payload": echo.file_list[echo.fragment - 1],
            "content": next_news['content'],
            "title": next_news['title'],
            "sha1": sha1
        })
        echo.fragment -= 1
        if echo.fragment > 0 and int(
                clients[client_param['imei']]['ts_trial']) > 0:
            printl("reset trials for file %s" % next_news['filepath'])
            clients[client_param['imei']]['ts_trial'] = int(
                clients[client_param['imei']]['ts_trial']) + 1
        clients[client_param['imei']]['ltf'] = echo.fragment
        mysend(socket, repl)
        if echo.file_list is not None:
            printl("frag=[%d/%d] frag=%d" %
                   (int(len(echo.file_list) - (echo.fragment)),
                    int(len(echo.file_list)), echo.fragment))

    #else:
    #    repl = bson.dumps({"ts":-1L,"frag":0,"type":1,"payload":b"null image"})

    printl("closing socket")

    socket.close()
예제 #58
0
 def protocol_parameters(self):
     """Get decoded protocol parameters if they do exist in the header"""
     pp = self.header().get('content', {}).get('protocol_parameters')
     if pp:
         return bson.loads(bytes.fromhex(pp)[4:])
예제 #59
0
import struct
import datetime

try:
    import bson
    HAVE_BSON = True
except ImportError:
    HAVE_BSON = False
else:
    # The BSON module provided by pymongo works through its "BSON" class.
    if hasattr(bson, "BSON"):
        bson_decode = lambda d: bson.BSON(d).decode()
    # The BSON module provided by "pip install bson" works through the
    # "loads" function (just like pickle etc.)
    elif hasattr(bson, "loads"):
        bson_decode = lambda d: bson.loads(d)
    else:
        HAVE_BSON = False

from lib.cuckoo.common.utils import get_filename_from_path
from lib.cuckoo.common.exceptions import CuckooResultError

log = logging.getLogger(__name__)

###############################################################################
# Generic BSON based protocol - by rep
# Allows all kinds of languages / sources to generate input for Cuckoo,
# thus we can reuse report generation / signatures for other API trace sources.
###############################################################################

TYPECONVERTERS = {
예제 #60
0
 def values(self):
     result = []
     for v in BDB.values(self):
         result.append(bson.loads(v))
     return result