After configuring this storage you need to create it explicitly.
13473
@Override
    public GraphHopperStorage create(long byteCount) {
        baseGraph.checkInit();
        if (encodingManager == null)
            throw new IllegalStateException("EncodingManager can only be null if you call loadExisting");

        dir.create();
        long initSize = Math.max(byteCount, 100);
        properties.create(100);

        properties.put("graph.bytes_for_flags", encodingManager.getBytesForFlags());
        properties.put("graph.flag_encoders", encodingManager.toDetailsString());

        properties.put("graph.byte_order", dir.getByteOrder());
        properties.put("graph.dimension", baseGraph.nodeAccess.getDimension());
        properties.putCurrentVersions();

        baseGraph.create(initSize);

        for (CHGraphImpl cg : getAllCHGraphs()) {
            cg.create(byteCount);
        }

        properties.put("graph.ch.weightings", getNodeBasedCHWeightings().toString());
        properties.put("graph.ch.edge.weightings", getEdgeBasedCHWeightings().toString());
        return this;
    }
961964
private void createDefaultConfigurationFile() throws IOException
    {
        
        File configFile = new File(configFilePath);
        
        if (configFile.exists()) {
            //seems a problem with access rights, report error
            throw new IOException();
        }
        else {
            //create the default file
            
            //create config dir if not exists yet
            File parentDir = configFile.getParentFile();
            if (!parentDir.exists())
                parentDir.mkdirs();
            
            //create config file
            configFile.createNewFile();
            
            Properties config = new Properties();
            
            fillDefaultProperties(config);
            
            OutputStream fileOutput = new FileOutputStream(configFile);
            config.store(fileOutput, automaticFileMsg);
        }
        
    }
522596
def setup_dirs(self, storage_dir):
        ''''''
        self.storage_dir = expanduser(storage_dir)
        if ' ' in self.storage_dir:
            raise ValueError('storage dir path cannot contain spaces, please '
                             'specify a path with --storage-dir')
        self.build_dir = join(self.storage_dir, 'build')
        self.dist_dir = join(self.storage_dir, 'dists')
1045340
protected function setUp()
    {
        if (empty($this->asset)) {
            return;
        }

        $this->asset = $this->normalizePath($this->asset);
        $this->realPath = $this->locateResource();

        // The asset has not been located, so the full path is the asset itself
        if (null === $this->realPath) {
            $this->realPath = $this->asset;
        }
        $this->absolutePath = $this->retrieveBundleWebFolder();
    }
883666
static Configuration setupAvatarNodeStorage(Configuration conf,
      StartupInfo startInfo, NamenodeProtocol primaryNamenode)
      throws IOException {
    
    // shared loations for image and edits
    URI img0 = NNStorageConfiguration.getURIKey(conf, "dfs.name.dir.shared0");
    URI img1 = NNStorageConfiguration.getURIKey(conf, "dfs.name.dir.shared1");
    URI edit0 = NNStorageConfiguration.getURIKey(conf, "dfs.name.edits.dir.shared0");
    URI edit1 = NNStorageConfiguration.getURIKey(conf, "dfs.name.edits.dir.shared1");
    
    // local locations for image and edits
    Collection<URI> namedirs = NNStorageConfiguration.getNamespaceDirs(conf, null);
    Collection<URI> editsdir = NNStorageConfiguration.getNamespaceEditsDirs(conf, null);

    // validate correctness of the configuration
    AvatarStorageSetup.validate(conf, 
        namedirs, editsdir, 
        img0, img1, edit0, edit1);
    
    FileSystem localFs = FileSystem.getLocal(conf).getRaw();
    
    URI ownSharedImage = null;
    URI ownSharedEdits = null;

    //
    // if we are instance one then copy from primary to secondary
    // otherwise copy from secondary to primary.
    //
    if (startInfo.instance == InstanceId.NODEONE) {
      ownSharedImage = img1;
      ownSharedEdits = edit1;
    } else if (startInfo.instance == InstanceId.NODEZERO) {
      ownSharedImage = img0;
      ownSharedEdits = edit0;
    }

    // allocate a new configuration and update fs.name.dir approprately
    // The shared device should be the first in the list.
    Configuration newconf = new Configuration(conf);
    AvatarStorageSetup.updateConf(startInfo, newconf, namedirs, img0, img1,
        "dfs.name.dir");

    // update fs.name.edits.dir approprately in the new configuration
    // The shared device should be the first in the list.
    AvatarStorageSetup.updateConf(startInfo, newconf, editsdir, edit0,
        edit1, "dfs.name.edits.dir");
    
    // copy fsimage directory if needed
    if (startInfo.isStandby) {
      
      // do not open edit log at startup
      newconf.setBoolean("dfs.namenode.openlog", false);
      
      // connect to primary
      String fsName = getRemoteNamenodeHttpName(conf, startInfo.instance);
      
      FSImage tempImage = new FSImage(newconf,
          NNStorageConfiguration.getNamespaceDirs(newconf),
          NNStorageConfiguration.getNamespaceEditsDirs(newconf), null);
      
      // will block until Primary has left the safemode
      CheckpointSignature cs = getCheckpointSignature(primaryNamenode);
      
      long lastCheckpointTxId = cs.mostRecentCheckpointTxId;
      
      if(cs.layoutVersion != FSConstants.LAYOUT_VERSION) {
        throw new IOException("Upgrade for standby is not supported");      
      }
     
      if (isFile(ownSharedImage)) {
        File destFile = new File (ownSharedImage.getPath());
        NNStorageDirectoryRetentionManager.backupFiles(localFs, destFile, conf);
      }
      if (isFile(ownSharedEdits)) {
        File destFile = new File (ownSharedEdits.getPath());
        NNStorageDirectoryRetentionManager.backupFiles(localFs, destFile, newconf);
      }

      // setup storage
      NNStorage tempStorage = tempImage.storage;
      tempStorage.format();
      tempStorage.setStorageInfo(cs);
      tempStorage.writeAll();
      tempImage.editLog.transitionNonFileJournals(tempStorage, false,
          Transition.FORMAT, null);
      tempImage.transitionNonFileImages(tempStorage, false, Transition.FORMAT);
      
      // we need to become the active writer to upload image successfully to
      // non-file images storage
      tempImage.editLog.recoverUnclosedStreams();

      // Download the image to all storage directories
      FLOG.info("Downloading image to all storage directories.");
      MD5Hash digest = downloadImageToStorage(fsName, lastCheckpointTxId, tempImage);
      List<StorageDirectory> badSds = new ArrayList<StorageDirectory>();
      tempStorage.checkpointUploadDone(lastCheckpointTxId, digest);
      FLOG.info("Downloading image to all storage directories. DONE");
      tempImage.saveDigestAndRenameCheckpointImage(lastCheckpointTxId, digest);
      tempStorage.reportErrorsOnDirectories(badSds, tempImage);
      tempStorage.close();
      tempImage.close();
    }
    return newconf;
  }
648208
def init_app(app, *storages):
    '''
    
    '''

    # Set default configuration
    app.config.setdefault('FS_SERVE', app.config.get('DEBUG', False))
    app.config.setdefault('FS_ROOT', join(app.instance_path, 'fs'))
    app.config.setdefault('FS_PREFIX', None)
    app.config.setdefault('FS_URL', None)
    app.config.setdefault('FS_BACKEND', DEFAULT_BACKEND)
    app.config.setdefault('FS_IMAGES_OPTIMIZE', False)

    state = app.extensions['fs'] = app.extensions.get('fs', {})
    for storage in storages:
        storage.configure(app)
        state[storage.name] = storage

    from .views import bp
    app.register_blueprint(bp, url_prefix=app.config['FS_PREFIX'])
324900
protected function setup_data() {
		if ( ! $storage = $this->get_storage() ) {
			return;
		}

		$_hash = spl_object_hash( $storage );

		if ( $storage instanceof Deferred_Storage && ! isset( static::$storages_was_read[ $_hash ] ) ) {
			$storage->read();
			static::$storages_was_read[ $_hash ] = true;
		}

		$this->set_value(
			$storage->get( $this->get_map_key() )
		);
	}
191440
protected function init()
    {
        $this->storageFolder = self::validatePath(Config::get('cms.storage.media.folder', 'media'), true);
        $this->storagePath = rtrim(Config::get('cms.storage.media.path', '/storage/app/media'), '/');

        $this->ignoreNames = Config::get('cms.storage.media.ignore', FileDefinitions::get('ignoreFiles'));

        $this->ignorePatterns = Config::get('cms.storage.media.ignorePatterns', ['^\..*']);

        $this->storageFolderNameLength = strlen($this->storageFolder);
    }
1061719
private void createStorage() throws TTException {

        LOGGER.debug("Creating storage with " + mDataNumbers + " nodes containing " + BLOCKS_IN_DATA
            + " blocks with " + IStorageModule.VIRTUAL_BLOCK_SIZE + " bytes each.");

        // Creating mirror
        jCloudsStorageModule =
            new JCloudsStorageModule(BLOCKS_IN_DATA * VIRTUAL_BLOCK_SIZE, Files.createTempDir());

        IData data = this.mRtx.getCurrentData();

        if (data != null) {
            return;
        }

        for (int i = 0; i < mDataNumbers; i++) {

            // Bootstrapping nodes containing clusterSize -many blocks/sectors.
            LOGGER.debug("Bootstraping node " + i + "\tof " + (mDataNumbers - 1));
            this.mRtx.bootstrap(new byte[HybridTreetankStorageModule.BYTES_IN_DATA]);
        }

        this.mRtx.commit();
    }
1354891
function (options) {
  if (!(this instanceof Store)) {
    return new Store(options)
  }

  this._opts = options || {}
  this.db = new Datastore({ filename: this._opts.filename, autoload: true })
}
591468
@Override
    protected void initializeStorage( File directory ) throws BinaryStoreException {
        // make sure the directory doesn't exist
        FileUtil.delete(directory);
        if (!directory.exists()) {
            logger.debug("Creating temporary directory for transient binary store: {0}", directory.getAbsolutePath());
            directory.mkdirs();
        }
        if (!directory.canRead()) {
            throw new BinaryStoreException(JcrI18n.unableToReadTemporaryDirectory.text(directory.getAbsolutePath(),
                                                                                       JAVA_IO_TMPDIR));
        }
        if (!directory.canWrite()) {
            throw new BinaryStoreException(JcrI18n.unableToWriteTemporaryDirectory.text(directory.getAbsolutePath(),
                                                                                        JAVA_IO_TMPDIR));
        }
    }
523825
def put_blob(storage_conn=None, **kwargs):
    '''
    
    '''
    if not storage_conn:
        storage_conn = get_storage_conn(opts=kwargs)

    if 'container' not in kwargs:
        raise SaltSystemExit(code=42, msg='The blob container name must be specified as "container"')

    if 'name' not in kwargs:
        raise SaltSystemExit(code=42, msg='The blob name must be specified as "name"')

    if 'blob_path' not in kwargs and 'blob_content' not in kwargs:
        raise SaltSystemExit(
            code=42,
            msg='Either a path to a file needs to be passed in as "blob_path" '
            'or the contents of a blob as "blob_content."'
        )

    blob_kwargs = {
        'container_name': kwargs['container'],
        'blob_name': kwargs['name'],
        'cache_control': kwargs.get('cache_control', None),
        'content_language': kwargs.get('content_language', None),
        'content_md5': kwargs.get('content_md5', None),
        'x_ms_blob_content_type': kwargs.get('blob_content_type', None),
        'x_ms_blob_content_encoding': kwargs.get('blob_content_encoding', None),
        'x_ms_blob_content_language': kwargs.get('blob_content_language', None),
        'x_ms_blob_content_md5': kwargs.get('blob_content_md5', None),
        'x_ms_blob_cache_control': kwargs.get('blob_cache_control', None),
        'x_ms_meta_name_values': kwargs.get('meta_name_values', None),
        'x_ms_lease_id': kwargs.get('lease_id', None),
    }
    if 'blob_path' in kwargs:
        data = storage_conn.put_block_blob_from_path(
            file_path=kwargs['blob_path'],
            **blob_kwargs
        )
    elif 'blob_content' in kwargs:
        data = storage_conn.put_block_blob_from_bytes(
            blob=kwargs['blob_content'],
            **blob_kwargs
        )

    return data
384232
def init_storage():
    
    # http://stackoverflow.com/a/600612/735926
    try:
        os.makedirs(DICTS_PATH)
    except OSError as ex:
        if ex.errno != errno.EEXIST or not os.path.isdir(DICTS_PATH):
            raise
436895
protected function createConfiguration()
    {

        // load the persistence unit configuration
        $persistenceUnitNode = $this->getPersistenceUnitNode();

        // load the metadata configuration
        $metadataConfiguration = $persistenceUnitNode->getMetadataConfiguration();

        // prepare the setup properties
        $absolutePaths = $metadataConfiguration->getDirectoriesAsArray();
        $proxyDir = $metadataConfiguration->getParam(MetadataConfigurationInterface::PARAM_PROXY_DIR);
        $proxyNamespace = $metadataConfiguration->getParam(MetadataConfigurationInterface::PARAM_PROXY_NAMESPACE);
        $autoGenerateProxyClasses = $metadataConfiguration->getParam(MetadataConfigurationInterface::PARAM_AUTO_GENERATE_PROXY_CLASSES);
        $useSimpleAnnotationReader = $metadataConfiguration->getParam(MetadataConfigurationInterface::PARAM_USE_SIMPLE_ANNOTATION_READER);

        // load the metadata driver factory class name
        $metadataDriverFactory = $metadataConfiguration->getFactory();

        // initialize the params to be passed to the factory
        $metadataDriverParams = array(DriverKeys::USE_SIMPLE_ANNOTATION_READER => $useSimpleAnnotationReader);

        // create the Doctrine ORM configuration
        $configuration = new Configuration();
        $configuration->setMetadataDriverImpl($metadataDriverFactory::get($configuration, $absolutePaths, $metadataDriverParams));

        // initialize the metadata cache configuration
        $metadataCacheConfiguration = $persistenceUnitNode->getMetadataCacheConfiguration();
        $configuration->setMetadataCacheImpl($this->getCacheImpl($metadataCacheConfiguration));

        // initialize the query cache configuration
        $queryCacheConfiguration = $persistenceUnitNode->getQueryCacheConfiguration();
        $configuration->setQueryCacheImpl($this->getCacheImpl($queryCacheConfiguration));

        // initialize the result cache configuration
        $resultCacheConfiguration = $persistenceUnitNode->getResultCacheConfiguration();
        $configuration->setResultCacheImpl($this->getCacheImpl($resultCacheConfiguration));

        // proxy configuration
        $configuration->setProxyDir($proxyDir = $proxyDir ?: sys_get_temp_dir());
        $configuration->setProxyNamespace($proxyNamespace = $proxyNamespace ?: 'Doctrine\Proxy');
        $configuration->setAutoGenerateProxyClasses($autoGenerateProxyClasses = $autoGenerateProxyClasses ?: true);

        // repository configuration
        $configuration->setDefaultRepositoryClassName($persistenceUnitNode->getDefaultRepositoryClassName());
        $configuration->setRepositoryFactory($this->getApplication()->search($persistenceUnitNode->getRepositoryFactory()));

        // return the configuration instance
        return $configuration;
    }
1237170
private void setupCacheThrough() {
    if (config.getCacheLoaderFactory() != null) {
      final CacheLoader<K, V> clf = config.getCacheLoaderFactory().create();
      cache2kConfiguration.setAdvancedLoader(
        new CustomizationReferenceSupplier<AdvancedCacheLoader<K, V>>(
          new CloseableLoader() {

            @Override
            public void close() throws IOException {
              if (clf instanceof Closeable) {
                ((Closeable) clf).close();
              }
            }

            @Override
            public V load(final K key, final long currentTime, final CacheEntry<K, V> currentEntry) {
              return clf.load(key);
            }

          }));
    }
    if (config.getCacheWriterFactory() != null) {
      final javax.cache.integration.CacheWriter<? super K, ? super V> cw = config.getCacheWriterFactory().create();
      cache2kConfiguration.setWriter(new CustomizationReferenceSupplier<CacheWriter<K, V>>(new CloseableWriter() {
        @Override
        public void write(final K key, final V value) {
          Cache.Entry<K, V> ce = new Cache.Entry<K, V>() {
            @Override
            public K getKey() {
              return key;
            }

            @Override
            public V getValue() {
              return value;
            }

            @Override
            public <T> T unwrap(Class<T> clazz) {
              throw new UnsupportedOperationException("unwrap entry not supported");
            }
          };
          cw.write(ce);
        }

        @Override
        public void delete(final Object key) {
          cw.delete(key);
        }

        @Override
        public void close() throws IOException {
          if (cw instanceof Closeable) {
            ((Closeable) cw).close();
          }
        }
      }));
    }
  }
526728
function install()
    {
        $this->createConfigurationDirectory();
        $this->createDriversDirectory();
        $this->createSitesDirectory();
        $this->createExtensionsDirectory();
        $this->createLogDirectory();
        $this->createCertificatesDirectory();
        $this->writeBaseConfiguration();

        $this->files->chown($this->path(), user());
    }
739287
@Constructed
	public void constructed() {
		Context context = factory.enterContext();
		
		try {
			scope = new ImporterTopLevel(context);
		} finally {
			Context.exit();
		}
		
		Container container = Jaguar.component(Container.class);
		Object store = container.component(container.contexts().get(Application.class)).store();
		
		if (store instanceof ServletContext) {
			org.eiichiro.bootleg.Configuration configuration = new DefaultConfiguration();
			configuration.init((ServletContext) store);
			this.configuration = configuration;
		}
	}