Returns a list of all the items secured in the vault
492099
def listTargets(self):
        '''
            
        '''
        sql = 'select * from {}'.format(self.TABLE_ITEMS)
        cursor = self.db.execute(sql)

        return [(iid, name, path) for iid, name, path in cursor]
124018
def _get_authz_session(self):
        
        from ..utilities import BOOTSTRAP_VAULT_TYPE
        try:
            vaults = self._get_vault_lookup_session().get_vaults_by_genus_type(BOOTSTRAP_VAULT_TYPE)
        except Unimplemented:
            return self._get_authz_manager().get_authorization_session()
        if vaults.available():
            vault = vaults.next()
            return self._get_authz_manager().get_authorization_session_for_vault(vault.get_id())
        else:
            return self._get_authz_manager().get_authorization_session()
358616
def items(self):
        """"""
        return list(zip((self.scalars + self.sections), list(self.values())))
443324
def get_items(self):
        
        url = self.build_url(self._endpoints.get('get_items'))

        response = self.con.get(url)

        if not response:
            return []

        data = response.json()

        return [self.list_item_constructor(parent=self,
                                           **{self._cloud_data_key: item})
                for item in data.get('value', [])]
1223307
def list_security_groups(self, retrieve_all=True, **_params):
        """"""
        return self.list('security_groups', self.security_groups_path,
                         retrieve_all, **_params)
635196
def _item_sources(self):
        """"""
        return [self.data_vars, self.coords, {d: self[d] for d in self.dims},
                LevelCoordinatesSource(self)]
678147
def list_ipsecpolicies(self, retrieve_all=True, **_params):
        """"""
        return self.list('ipsecpolicies',
                         self.ipsecpolicies_path,
                         retrieve_all,
                         **_params)
52859
def pool
      @lock.synchronize do
        return @nhp if @nhp

        @nhp = PersistentHTTP.new("vault-ruby", nil, pool_size)

        if proxy_address
          proxy_uri = URI.parse "http://#{proxy_address}"

          proxy_uri.port = proxy_port if proxy_port

          if proxy_username
            proxy_uri.user = proxy_username
            proxy_uri.password = proxy_password
          end

          @nhp.proxy = proxy_uri
        end

        # Use a custom open timeout
        if open_timeout || timeout
          @nhp.open_timeout = (open_timeout || timeout).to_i
        end

        # Use a custom read timeout
        if read_timeout || timeout
          @nhp.read_timeout = (read_timeout || timeout).to_i
        end

        @nhp.verify_mode = OpenSSL::SSL::VERIFY_PEER

        # Vault requires TLS1.2
        @nhp.ssl_version = "TLSv1_2"

        # Only use secure ciphers
        @nhp.ciphers = ssl_ciphers

        # Custom pem files, no problem!
        pem = ssl_pem_contents || (ssl_pem_file ? File.read(ssl_pem_file) : nil)
        if pem
          @nhp.cert = OpenSSL::X509::Certificate.new(pem)
          @nhp.key = OpenSSL::PKey::RSA.new(pem, ssl_pem_passphrase)
        end

        # Use custom CA cert for verification
        if ssl_ca_cert
          @nhp.ca_file = ssl_ca_cert
        end

        # Use custom CA path that contains CA certs
        if ssl_ca_path
          @nhp.ca_path = ssl_ca_path
        end

        if ssl_cert_store
          @nhp.cert_store = ssl_cert_store
        end

        # Naughty, naughty, naughty! Don't blame me when someone hops in
        # and executes a MITM attack!
        if !ssl_verify
          @nhp.verify_mode = OpenSSL::SSL::VERIFY_NONE
        end

        # Use custom timeout for connecting and verifying via SSL
        if ssl_timeout || timeout
          @nhp.ssl_timeout = (ssl_timeout || timeout).to_i
        end

        @nhp
      end
    end
406908
def get_items(self):
        """"""
        ils = get_item_lookup_session(runtime=self._runtime, proxy=self._proxy)
        ils.use_federated_bank_view()
        items = []
        if self.has_items():
            for idstr in self._my_map['itemIds']:
                items.append(ils.get_item(Id(idstr)))
        return ItemList(items, runtime=self._runtime, proxy=self._proxy)
312459
def attributes
      {
        :vault_id => vault_id,
        :currency => currency,
        :card_number => card_number,
        :cvv_number => cvv_number,
        :expires_on => expires_on,
        :first_name => first_name,
        :last_name => last_name,
        :street_address => street_address,
        :locality => locality,
        :region => region,
        :postal_code => postal_code,
        :country => country,
        :phone => phone
      }
    end
176026
def list_vault_ec2_certificate_configurations(self, mount_point='aws-ec2'):
        
        params = {'list': True}
        return self._adapter.get('/v1/auth/{0}/config/certificates'.format(mount_point), params=params).json()
1194652
def getItemDPList(self):
        """"""
        itemlist = [(item, item._dp) for item in self.iterator()]
        return itemlist
1244272
def index
      @lists = {}
      unless @dt_request.provided?
        Incline::ActionSecurity.valid_items   # ensure only valid items are in the database.

        # build lists for the dropdown filters.
        @lists[:controller_name] = Incline::ActionSecurity.visible.pluck(:controller_name).uniq.sort
        @lists[:action_name] = Incline::ActionSecurity.visible.pluck(:action_name).uniq.sort
        @lists[:short_permitted] = Incline::ActionSecurity::SHORT_PERMITTED_FILTERS
      end
    end
929195
def recvSecurityList(self, data):
        
        securityList = []
        while data.dataLen() > 0:
            securityElement = UInt8()
            data.readType(securityElement)
            securityList.append(securityElement)
        #select high security level
        for s in securityList:
            if s.value in [SecurityType.NONE, SecurityType.VNC] and s > self._securityLevel:
                self._securityLevel = s
                break
        #send back security level choosen
        self.send(self._securityLevel)
        if self._securityLevel.value == SecurityType.VNC:
            self.expect(16, self.recvVNCChallenge)
        else:
            self.expect(4, self.recvSecurityResult)
561883
def list_recursive(list_prefix, parent = '')
      me = File.join(parent, list_prefix)
      result = vault_client.logical.list(me).inject({}) do |hash, item|
        case item
        when /.*\/$/
          hash[item.gsub(/\/$/, '').to_sym] = list_recursive(item, me)
        else
          hash[item.to_sym] = read_data(item, me)
        end
        hash
      end
      result
    end
1332570
def vault_relation_complete(backend=None):
    """"""
    vault_kv = VaultKVContext(secret_backend=backend or VAULTLOCKER_BACKEND)
    vault_kv()
    return vault_kv.complete
929392
def sync_auth(self, vault_client, resources):
        """"""
        for auth in self.auths():
            auth.sync(vault_client)

        auth_resources = [x for x in resources
                          if isinstance(x, (LDAP, UserPass))]
        for resource in auth_resources:
            resource.sync(vault_client)

        return [x for x in resources
                if not isinstance(x, (LDAP, UserPass, AuditLog))]