Python Storage.add方法代码示例

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import add [as 别名]
    def add(self, item):
        bookmark = self.find(item)

        if not bookmark:
            Storage.add(self, item)

            self.save()

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import add [as 别名]
class ColorBuilder(object):
    def __init__(self, seed, kernel, printer):
        self.__seed = seed
        self.__kernel = kernel
        self.__storage = Storage()
        self.__knownTxs = set((seed.txhash,))
        self.__access = rpc_access.fromFile('../data/rpc.ini')
        self.__printer = printer
        coloredTxs = self.__storage.get_all(seed.color_id)
        for tx in coloredTxs:
            self.__knownTxs.add(str(tx[0]))
            
    def isColored(self, tx):
        for inp in tx.inputs:
            if ('txid' in inp) and (inp['txid'] in self.__knownTxs):
                return True
        return False

    def processBlock(self, blockHeight):
        txhashes = self.__access.getblock(self.__access.getblockhash(blockHeight))['tx']
        for txhash in txhashes:
            tx = Transaction(self.__access.getrawtransaction(txhash, 1))
            if not self.isColored(tx):
                continue
            
            colorVals = list()
            self.__printer(txhash + ", inputs: " + str(len(tx.inputs)) + ", outputs: " + str(len(tx.outputs)))

            for inp in tx.inputs:
                prevHash = inp['txid']
                prevTx = Transaction(self.__access.getrawtransaction(prevHash, 1))
#                   print(str(t1.duration_in_seconds())  + ", inputs: " + str(len(prevTx['vin'])) + ", outputs: " + str(len(prevTx['vout'])))
                prevOutIndex = inp['outindx']
                colorVal = self.__storage.get(self.__seed.color_id, prevHash, prevOutIndex)
                colorVals.append((prevTx.outputs[prevOutIndex], colorVal))
            colorOuts = self.__kernel(tx, colorVals)

            colorFound = False
            for i, colorOut in enumerate(colorOuts):
                if colorOut[0] != 0:
                    self.__storage.add(self.__seed.color_id, txhash, i, colorOut[0], colorOut[1])
                    colorFound = True
            if colorFound:
                self.__knownTxs.add(str(txhash))
                

    def build(self):
        seedTransaction = self.__access.getrawtransaction(self.__seed.txhash, 1)
        for i, seedOut in enumerate(self.__seed.outputs):
            self.__storage.add(self.__seed.color_id, self.__seed.txhash, i, seedOut.value, seedOut.label)
            
        block = self.__access.getblock(seedTransaction['blockhash'])
        blockHeight = block['height']
        while blockHeight <= self.__access.getblockcount():
            self.__printer(blockHeight)
            self.processBlock(blockHeight)
            blockHeight += 1

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import add [as 别名]
class HashIndex(Index):
    """
    Индекс, опирающийся на результаты работы функции hash
    совместно с функцией-селектором.
    """

    def __init__(self, config, name, selector=lambda x: x):
        super(HashIndex, self).__init__(config, name)
        self._selector = selector
        self._storage = Storage('LL', self._make_buffer())

        # словарь для получения позиции в буфере по id объекта
        self._id_to_pos = None
        # словарь списков id обхектов,
        # ключи которого - результаты вычисления hash(selector(x))
        self._index = None

    def _build(self):
        # построение индекса из буфера
        self._id_to_pos = {}
        self._index = {}
        for pos, (id_, hash_) in enumerate(self._storage):
            self._id_to_pos[id_] = pos
            self._index.setdefault(hash_, []).append(id_)

    @_lazy
    def indexate(self, data, id_):
        if id_ in self._id_to_pos:
            raise ValueError('Object with id="%s" already indexed!' % id_)

        hash_ = hash(self._selector(data)) # ключ индекса
        self._index.setdefault(hash_, []).append(id_)
        self._id_to_pos[id_] = self._storage.add((id_, hash_))

    @_lazy
    def forget(self, id_):
        if id_ not in self._id_to_pos:
            raise ValueError('Object with id="%s" is not indexed!' % id_)

        for l in self._index.values():
            try:
                l.remove(id_)
            except ValueError:
                pass

        self._storage.remove(self._id_to_pos[id_])
        del self._id_to_pos[id_]

    @_lazy
    def query(self, val):
        return self._index.get(hash(val), [])

# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import add [as 别名]
class TestStorageAPI():

   def __init__(self):
       db = Database({
           "type": 'postgresql',
           "host": 'fg-cn-decaf-head1.cs.upb.de',
           "port": '5432',
           "database": 'decaf_storage',
           "user": 'pgdecaf',
           "password": 'pgdecafpw'
       })
       #db.drop_all()
       db.init_db()
       # Configure logging
       log_file = LOGFILE
       logger = logging.getLogger(__name__)
       logger.setLevel(logging.DEBUG)
       fh = logging.FileHandler(log_file)
       logger.addHandler(fh)

       self.storage = Storage(db, logger=logger)

   def test_scenario_insert(self):
       # create VNF
       code, vnf_id = self.storage.add(Vnf,{
           'name': 'name',
           'description': 'description',
           'path': 'path',
           'public': False
       })
       print('VNF: ', vnf_id)

       # create Image
       code, image_id = self.storage.add(Image,{
           'name': 'name',
           'description': 'description',
           'location': 'location'
       })
       print('Image: ', image_id)
       # create Flavor

       code, flavor_id = self.storage.add(Flavor,{
           'name': 'name',
           'description': 'description',
           'disk': 12,
           'ram': 8,
           'vcpus': 4
       })
       print('Flavor: ', flavor_id)

       # create VM
       code, vm_id = self.storage.add(Vm,{
           'name': 'name',
           'description': 'description',
           'vnf_id': vnf_id,
           'flavor_id': flavor_id,
           'image_id': image_id,
           'image_path': 'http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img'
       })
       print('VM: ', vm_id)

       # create Scenario
       code, sce_id = self.storage.add(Scenario, {
           'name': 'name',
           'description': 'description'
       })
       print('Scenario: ', sce_id)

       # add Vnf to Scenario
       code, scenario_vnf = self.storage.add(ScenarioVnf, {
           'name': 'name',
           'description': 'description',
           'scenario_id': sce_id,
           'vnf_id': vnf_id
       })
       print('Scenario VNF: ', scenario_vnf)

       code, vnfs = self.storage.get(Vnf,
                                     filters={'vnf.uuid': vnf_id},
                                     options=['vms', 'scenario_vnfs.scenario'])

       for vnf in vnfs:
           print(json.dumps(vnf, cls=StorageJSONEncoder, check_circular=True))
           vnf = json.loads(json.dumps(vnf, cls=StorageJSONEncoder, check_circular=True))
           print("VMS:\n", json.dumps(vnf['vms']))