private void RecompileController(DynamicCompilationInfo info)
        {
            if (info.TimeStamp != default(DateTime))
            {
                if ((DateTime.Now - info.TimeStamp).Seconds < 1)
                {
                    _logger.LogDebug("Skipping duplicate change token");
                    return;
                }
            }

            var controllerModel = (ControllerModel)info.Tag;

            _logger?.LogInformation($"Start recompiling controller {controllerModel.ControllerName}");

            var module       = CompileControllerModule(info.CodeSource);
            var canRecompile = controllerModel.Attributes.OrderBy(x => x.GetType())
                               .SequenceEqual(MapAnnotationsToAttributes(_classAttribResolver.Attributes)
                                              .OrderBy(x => x.GetType()));

            if (!canRecompile)
            {
                _logger?.LogError($"Can't recompile controller {controllerModel.ControllerName} when list of attributes has changed");
                return;
            }

            info.Module    = module;
            info.TimeStamp = DateTime.Now;
            _logger?.LogInformation($"Controller {controllerModel.ControllerName} has been recompiled");
        }
        private void FillContext(IEnumerable <IFileInfo> sources, ApplicationModelProviderContext context)
        {
            var reflector = new TypeReflectionEngine();

            MachineInstance.Current.PrepareThread(_fw.Environment);
            foreach (var virtualPath in sources)
            {
                LoadedModule       module;
                FileInfoCodeSource codeSrc;
                string             typeName;
                if (virtualPath.IsDirectory)
                {
                    var info = FindModule(virtualPath.Name, MODULE_FILENAME)
                               ?? FindModule(virtualPath.Name, virtualPath.Name + ".os");

                    if (info == null)
                    {
                        continue;
                    }

                    codeSrc  = new FileInfoCodeSource(info);
                    typeName = virtualPath.Name;
                }
                else
                {
                    codeSrc  = new FileInfoCodeSource(virtualPath);
                    typeName = System.IO.Path.GetFileNameWithoutExtension(virtualPath.Name);
                }

                module = CompileControllerModule(codeSrc);

                var reflectedType = reflector.Reflect <ScriptedController>(module, typeName);
                var attrList      = MapAnnotationsToAttributes(_classAttribResolver.Attributes);
                var cm            = new ControllerModel(typeof(ScriptedController).GetTypeInfo(), attrList.AsReadOnly());
                cm.ControllerName = reflectedType.Name;
                var recompileInfo = new DynamicCompilationInfo()
                {
                    Module     = module,
                    CodeSource = codeSrc,
                    Tag        = cm
                };

                cm.Properties.Add("CompilationInfo", recompileInfo);
                cm.Properties.Add("type", reflectedType);

                ChangeToken.OnChange(() => CreateWatchToken(codeSrc),
                                     RecompileController,
                                     recompileInfo);

                FillActions(cm, reflectedType);
                FillFilters(cm);

                context.Result.Controllers.Add(cm);
            }
        }