Hi Andrew

Not really had a look at V9 yet but, could you have an appsetting flag for 'UseSharedMediaFileSystemOrSomething' in appsettings

which could then be different for each environment, using an appropriate

appsettings.{environment}.json file:

https://our.umbraco.com/documentation/Reference/V9-Config/

Then because the configuration is now via code - could you read the appsetting value and only change the mediafilesystem in the composer when the environment is Not test or production?

eg wrap the code that changes the underlying mediafilesystem inside an If that checks the appsetting?

regards

Marc

Did you manage to solve this issue? Did you go down the custom file system route with some kind of if-statement to only use the custom file system on Development? Or did you find another way to get this done?

thanks Warren

yes we had since worked out a solution along those lines but i forgot to say in this thread - good info for someone else finding this thread so thank you

Andrew

For those of you who are interested, I'm using the following setup:

appsettings.json (this can be omitted, because I'm only using the custom path settings on Development and Staging, but I left it in for clarity)

{
  "Application": {
    "Media": {
      "RootPath": ""
    }
  }
}

appsettings.Development.json

{
  "Application": {
    "Media": {
      "RootPath": "D:\\Dropbox\\UmbracoMedia\\umbraco9\\media"
    }
  }
}

ApplicationSettings.cs

using System.ComponentModel;
using Umbraco.Cms.Core.Configuration.Models;

namespace Application.Core.Models.Configuration
{
    [UmbracoOptions("Application")]
    public class ApplicationSettings
    {
        public MediaSettings Media { get; set; }
   }

    public class MediaSettings
    {
        public string RootPath { get; set; }
    }
}

Startup.cs

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        { ... }

        if (env.IsProduction() == false)
        {
            var mediaSettings = new MediaSettings();
            _config.GetSection("Application").GetSection("Media").Bind(mediaSettings);

            if (string.IsNullOrEmpty(mediaSettings.RootPath) == false)
            {
                app.UseStaticFiles(new StaticFileOptions
                {
                    FileProvider = new PhysicalFileProvider(mediaSettings.RootPath),
                    RequestPath = "/media"
                });
            }
        }
    }

MediaFileSystem.cs

using Application.Core.Extensions;
using Application.Core.Models.Configuration;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Umbraco.Cms.Core.Composing;
using Umbraco.Cms.Core.DependencyInjection;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Infrastructure.DependencyInjection;
using IHostingEnvironment = Umbraco.Cms.Core.Hosting.IHostingEnvironment;

namespace Application.Core.Composing
{
    public class MediaFileSystemComposer : IComposer
    {
        public void Compose(IUmbracoBuilder builder)
        {
            builder.SetMediaFileSystem((factory) =>
            {
                var webHostEnvironment = factory.GetRequiredService<IWebHostEnvironment>();
                var hostingEnvironment = factory.GetRequiredService<IHostingEnvironment>();
                var rootPath = hostingEnvironment.MapPathWebRoot("~/media");
                var rootUrl = "/media";

                if (webHostEnvironment.IsProduction() == false)
                {
                    var mediaSettings = new MediaSettings();
                    builder.Config.GetSection("Application").GetSection("Media").Bind(mediaSettings);

                    if (string.IsNullOrEmpty(mediaSettings.RootPath) == false)
                    {
                        rootPath = mediaSettings.RootPath;
                    }
                }

                return new PhysicalFileSystem(
                    factory.GetRequiredService<IIOHelper>(),
                    hostingEnvironment,
                    factory.GetRequiredService<ILogger<PhysicalFileSystem>>(),
                    rootPath,
                    rootUrl);
            });
        }
    }
}

This way I can use a shared folder on Development and Staging and the wwwroot/media folder on Production.

The previous code examples didn't play well with ImageSharp. But if anyone is looking for a working solution until Umbraco comes up with an out-of-the-box solution for this problem, please check out the following example:

https://github.com/umbraco/Umbraco-CMS/issues/11580#issuecomment-991716300

is working on a reply...