Package voldemort.xml

Examples of voldemort.xml.StoreDefinitionsMapper


        List<Versioned<String>> versionedStoreList = innerStore.get(STORES_KEY, "");

        if(versionedStoreList != null) {
            String stores = versionedStoreList.get(0).getValue();
            StoreDefinitionsMapper mapper = new StoreDefinitionsMapper();
            List<StoreDefinition> storeDefinitions = mapper.readStoreList(new StringReader(stores));
            for(StoreDefinition storeDef: storeDefinitions) {
                Versioned<String> versionedStoreValue = new Versioned<String>(mapper.writeStore(storeDef));
                storesRepo.put(storeDef.getName(), versionedStoreValue, null);
            }
        }
        this.storeDefinitionsStorageEngine = storesRepo;
View Full Code Here


            throw new IllegalArgumentException("No configuration found in " + dir.getAbsolutePath()
                                               + ".");

        if(!configurationFiles.contains(STORE_DEFINITIONS_STORE_NAME)) {
            // parse stores.xml and create STORES sub-dir
            StoreDefinitionsMapper mapper = new StoreDefinitionsMapper();
            List<StoreDefinition> storeDefinitions = null;
            try {
                storeDefinitions = mapper.readStoreList(new File(dir.getAbsolutePath()
                                                                 + File.separator + STORES_KEY));
            } catch(IOException e) {
                throw new VoldemortException("Cannot parse the store definitions from "
                                             + STORES_KEY + " file ", e);
            }

            if(storeDefinitions == null) {
                throw new VoldemortException("Neither STORES nor stores.xml exist in the config directory");
            }

            // Create the STORES sub directory
            File storeDefinitionsDir = new File(storeDefDirPath);
            if(!storeDefinitionsDir.mkdir()) {
                throw new VoldemortException("Unable to create " + STORE_DEFINITIONS_STORE_NAME
                                             + " sub directory");
            }
            for(StoreDefinition storeDef: storeDefinitions) {
                try {
                    FileUtils.writeStringToFile(new File(storeDefDirPath + File.separator
                                                         + storeDef.getName()),
                                                mapper.writeStore(storeDef));
                } catch(IOException e) {
                    throw new VoldemortException("Cannot write store definition to file: "
                                                 + storeDef.getName(), e);
                }
            }
View Full Code Here

                    storeNamesToDelete.add(storeName);
                }

                // Add / update the list of store definitions specified in the
                // value
                StoreDefinitionsMapper mapper = new StoreDefinitionsMapper();

                // Update the STORES directory and the corresponding entry in
                // metadata cache
                Set<String> specifiedStoreNames = new HashSet<String>();
                for(StoreDefinition storeDef: storeDefinitions) {
                    specifiedStoreNames.add(storeDef.getName());
                    String storeDefStr = mapper.writeStore(storeDef);
                    Versioned<String> versionedValueStr = new Versioned<String>(storeDefStr,
                                                                                value.getVersion());
                    this.storeDefinitionsStorageEngine.put(storeDef.getName(),
                                                           versionedValueStr,
                                                           "");
View Full Code Here

        try {
            Versioned<String> value = new Versioned<String>(ByteUtils.getString(valueBytes.getValue(),
                                                                                "UTF-8"),
                                                            valueBytes.getVersion());
            Versioned<Object> valueObject = convertStringToObject(STORES_KEY, value);
            StoreDefinitionsMapper mapper = new StoreDefinitionsMapper();
            List<StoreDefinition> storeDefinitions = (List<StoreDefinition>) valueObject.getValue();

            // Check for backwards compatibility
            StoreDefinitionUtils.validateSchemasAsNeeded(storeDefinitions);

            // Go through each store definition and do a corresponding put
            for(StoreDefinition storeDef: storeDefinitions) {
                if(!this.storeNames.contains(storeDef.getName())) {
                    throw new VoldemortException("Cannot update a store which does not exist !");
                }

                String storeDefStr = mapper.writeStore(storeDef);
                Versioned<String> versionedValueStr = new Versioned<String>(storeDefStr,
                                                                            value.getVersion());
                this.storeDefinitionsStorageEngine.put(storeDef.getName(), versionedValueStr, "");

                // Update the metadata cache
View Full Code Here

            // Check for backwards compatibility
            StoreDefinitionUtils.validateSchemaAsNeeded(storeDef);

            // Otherwise add to the STORES directory
            StoreDefinitionsMapper mapper = new StoreDefinitionsMapper();
            String storeDefStr = mapper.writeStore(storeDef);
            Versioned<String> versionedValueStr = new Versioned<String>(storeDefStr);
            this.storeDefinitionsStorageEngine.put(storeDef.getName(), versionedValueStr, null);

            // Update the metadata cache
            this.metadataCache.put(storeDef.getName(), new Versioned<Object>(storeDefStr));
View Full Code Here

        try {
            JsonReader reader = new JsonReader(new BufferedReader(new FileReader(inputFile),
                                                                  ioBufferSize));
            Cluster cluster = new ClusterMapper().readCluster(new BufferedReader(new FileReader(clusterFile)));
            StoreDefinition storeDef = null;
            List<StoreDefinition> stores = new StoreDefinitionsMapper().readStoreList(new BufferedReader(new FileReader(storeDefFile)));
            for(StoreDefinition def: stores) {
                if(def.getName().equals(storeName))
                    storeDef = def;
            }
View Full Code Here

    public static boolean isSystemStore(String storeName) {
        return (null == storeName ? false : storeName.startsWith(NAME_PREFIX));
    }

    public static List<StoreDefinition> getAllSystemStoreDefs() {
        return (new StoreDefinitionsMapper()).readStoreList(new StringReader(SystemStoreConstants.SYSTEM_STORE_SCHEMA));
    }
View Full Code Here

                Utils.mkdirs(outputDir);
            }

            try {
                FileUtils.writeStringToFile(new File(outputDirName, fileName),
                                            new StoreDefinitionsMapper().writeStoreList(storeDefs));
            } catch(IOException e) {
                logger.error("IOException during dumpStoreDefsToFile: " + e);
            }
        }
    }
View Full Code Here

    private boolean saveKeys;
    private boolean reducerPerBucket;

    public void configure(JobConf conf) {
        this.cluster = new ClusterMapper().readCluster(new StringReader(conf.get("cluster.xml")));
        List<StoreDefinition> storeDefs = new StoreDefinitionsMapper().readStoreList(new StringReader(conf.get("stores.xml")));
        if(storeDefs.size() != 1)
            throw new IllegalStateException("Expected to find only a single store, but found multiple!");
        this.storeDef = storeDefs.get(0);

        this.numChunks = conf.getInt("num.chunks", -1);
View Full Code Here

        }
    }

    private StoreDefinition getStoreDefinition(AbstractStoreClientFactory factory, String storeName) {
        String storesXml = factory.bootstrapMetadataWithRetries(MetadataStore.STORES_KEY);
        StoreDefinitionsMapper storeMapper = new StoreDefinitionsMapper();
        List<StoreDefinition> storeDefinitionList = storeMapper.readStoreList(new StringReader(storesXml));

        StoreDefinition storeDef = null;
        for(StoreDefinition storeDefinition: storeDefinitionList) {
            if(storeName.equals(storeDefinition.getName())) {
                storeDef = storeDefinition;
View Full Code Here

TOP

Related Classes of voldemort.xml.StoreDefinitionsMapper

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.