Ejemplo n.º 1
0
        public string GetContent(string file)
        {
            int fileId = 0;

            if (int.TryParse(file, out fileId))
            {
                var f = FileManager.Instance.GetFile(fileId);
                if (f != null)
                {
                    var fileContent = FileManager.Instance.GetFileContent(f);
                    if (fileContent != null)
                    {
                        using (var reader = new StreamReader(fileContent, Encoding.UTF8))
                        {
                            return(reader.ReadToEnd());
                        }
                    }
                }
                return("");
            }
            else
            {
                var f = FileUri.FromPath(file);
                if (f.FileExists)
                {
                    return(File.ReadAllText(f.PhysicalFilePath));
                }
                return("");
            }
        }
Ejemplo n.º 2
0
        public string Execute(Page page, TemplateFiles files, string templateVirtualFolder, object model)
        {
            var sourceFileUri = new FileUri(templateVirtualFolder + "/" + files.Template);

            try
            {
                string source       = File.ReadAllText(sourceFileUri.PhysicalFilePath);
                string sourceFolder = sourceFileUri.UrlFolder;
                var    hbs          = HandlebarsDotNet.Handlebars.Create();

                RegisterHelpers(hbs);
                RegisterScriptHelper(hbs);
                RegisterHandlebarsHelper(hbs);
                RegisterRegisterStylesheetHelper(hbs, page, sourceFolder);
                RegisterRegisterScriptHelper(hbs, page, sourceFolder);
                if (files.PartialTemplates != null)
                {
                    foreach (var part in files.PartialTemplates.Where(t => t.Value.ClientSide == false))
                    {
                        RegisterTemplate(hbs, part.Key, templateVirtualFolder + "/" + part.Value.Template);
                    }
                }
                return(CompileTemplate(hbs, source, model));
            }
            catch (Exception ex)
            {
                Log.Logger.Error(string.Format("Failed to render Handlebar template source:[{0}], model:[{1}]", sourceFileUri.PhysicalFilePath, model), ex);
                throw new TemplateException("Failed to render Handlebar template " + sourceFileUri.PhysicalFilePath, ex, model, sourceFileUri.PhysicalFilePath);
            }
        }
Ejemplo n.º 3
0
        public FileTreeViewItem([NotNull] FileUri fileUri) : base(fileUri.Site)
        {
            Assert.ArgumentNotNull(fileUri, nameof(fileUri));

            FileUri = fileUri;
            Icon    = new Icon("Resources/16x16/document.png");
        }
Ejemplo n.º 4
0
        private FileUri CheckFiles(TemplateManifest templateManifest, TemplateFiles files)
        {
            if (files == null)
            {
                throw new Exception("Manifest.json missing or incomplete");
            }
            var templateUri = new FileUri(templateManifest.ManifestFolderUri, files.Template);

            if (!templateUri.FileExists)
            {
                throw new Exception("Template " + templateUri.UrlFilePath + " don't exist");
            }
            if (files.PartialTemplates != null)
            {
                foreach (var partial in files.PartialTemplates)
                {
                    var partialTemplateUri = new FileUri(templateManifest.ManifestFolderUri, partial.Value.Template);
                    if (!partialTemplateUri.FileExists)
                    {
                        throw new Exception("PartialTemplate " + partialTemplateUri.UrlFilePath + " don't exist");
                    }
                }
            }
            return(templateUri);
        }
Ejemplo n.º 5
0
        private string GenerateOutputDetail(Page page, TemplateManifest templateManifest, TemplateFiles files, JToken dataJson, string settingsJson)
        {
            // detail template
            var templateVirtualFolder = templateManifest.ManifestFolderUri.UrlFolder;

            if (!string.IsNullOrEmpty(files.Template))
            {
                string  physicalTemplateFolder = HostingEnvironment.MapPath(templateVirtualFolder);
                FileUri templateUri            = CheckFiles(templateManifest, files);

                if (dataJson != null)
                {
                    var mf = new ModelFactorySingle(_renderinfo.Data, settingsJson, physicalTemplateFolder, _renderinfo.Template.Manifest, _renderinfo.Template, files, _module, PortalSettings.Current);
                    mf.Detail = true;
                    object model;
                    if (templateUri.Extension != ".hbs") // razor
                    {
                        model = mf.GetModelAsDynamic();
                    }
                    else // handlebars
                    {
                        if (OpenContentControllerFactory.Instance.OpenContentGlobalSettingsController.GetFastHandlebars())
                        {
                            model = mf.GetModelAsDictionary();
                        }
                        else
                        {
                            model = mf.GetModelAsDynamic();
                        }
                    }
                    if (!string.IsNullOrEmpty(_renderinfo.Template.Manifest.DetailMetaTitle))
                    {
                        HandlebarsEngine hbEngine = new HandlebarsEngine();
                        //page.Title
                        MetaTitle = hbEngine.Execute(_renderinfo.Template.Manifest.DetailMetaTitle, model);
                    }
                    if (!string.IsNullOrEmpty(_renderinfo.Template.Manifest.DetailMetaDescription))
                    {
                        HandlebarsEngine hbEngine = new HandlebarsEngine();
                        //PageUtils.SetPageDescription(page, hbEngine.Execute(_renderinfo.Template.Manifest.DetailMetaDescription, model));
                        MetaDescription = hbEngine.Execute(_renderinfo.Template.Manifest.DetailMetaDescription, model);
                    }
                    if (!string.IsNullOrEmpty(_renderinfo.Template.Manifest.DetailMeta))
                    {
                        HandlebarsEngine hbEngine = new HandlebarsEngine();
                        //PageUtils.SetPageMeta(page, hbEngine.Execute(_renderinfo.Template.Manifest.DetailMeta, model));
                        MetaOther = hbEngine.Execute(_renderinfo.Template.Manifest.DetailMeta, model);
                    }
                    return(ExecuteTemplate(page, templateManifest, files, templateUri, model));
                }
                else
                {
                    return("");
                }
            }
            else
            {
                return("");
            }
        }
Ejemplo n.º 6
0
        private static void IncludeResourses(Page page, RenderInfo renderInfo)
        {
            var template = renderInfo.Template;

            if (template != null)
            {
                if (template.MainTemplateUri() != null)
                {
                    if (!App.Services.CreateGlobalSettingsRepository(PortalSettings.Current.PortalId).GetCompositeCss())
                    {
                        var cssfilename = new FileUri(Path.ChangeExtension(template.MainTemplateUri().FilePath, "css"));
                        if (cssfilename.FileExists)
                        {
                            App.Services.ClientResourceManager.RegisterStyleSheet(page, cssfilename.UrlFilePath);
                        }
                    }
                    var jsfilename = new FileUri(Path.ChangeExtension(template.MainTemplateUri().FilePath, "js"));
                    if (jsfilename.FileExists)
                    {
                        App.Services.ClientResourceManager.RegisterScript(page, jsfilename.UrlFilePath, 100);
                    }
                }
                if (renderInfo.IsDetailPageRequest && template.DetailTemplateUri() != null)
                {
                    var cssfilename = new FileUri(Path.ChangeExtension(template.DetailTemplateUri().FilePath, "css"));
                    if (cssfilename.FileExists)
                    {
                        App.Services.ClientResourceManager.RegisterStyleSheet(page, cssfilename.UrlFilePath);
                    }
                }
                App.Services.ClientResourceManager.RegisterScript(page, "~/DesktopModules/OpenContent/js/opencontent.js");
            }
        }
Ejemplo n.º 7
0
        private string GenerateListOutput(Page page, TemplateManifest templateManifest, TemplateFiles files, IEnumerable <IDataItem> dataList, string settingsJson)
        {
            var templateVirtualFolder = templateManifest.ManifestFolderUri.UrlFolder;

            if (!string.IsNullOrEmpty(files.Template))
            {
                string  physicalTemplateFolder = HostingEnvironment.MapPath(templateVirtualFolder);
                FileUri templateUri            = CheckFiles(templateManifest, files);
                if (dataList != null)
                {
                    ModelFactoryMultiple mf = new ModelFactoryMultiple(dataList, settingsJson, physicalTemplateFolder, _renderinfo.Template.Manifest, _renderinfo.Template, files, _module, PortalSettings.Current);
                    object model;
                    if (templateUri.Extension != ".hbs") // razor
                    {
                        model = mf.GetModelAsDynamic();
                    }
                    else // handlebars
                    {
                        if (OpenContentControllerFactory.Instance.OpenContentGlobalSettingsController.GetFastHandlebars())
                        {
                            model = mf.GetModelAsDictionary();
                        }
                        else
                        {
                            model = mf.GetModelAsDynamic();
                        }
                    }
                    return(ExecuteTemplate(page, templateManifest, files, templateUri, model));
                }
            }
            return("");
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Возвращает файл.
        /// </summary>
        /// <param name="fileUniqueID">Уникальный идентификатор файла.</param>
        /// <param name="loadOptions">Опции загрузки файла.</param>
        /// <param name="throwIfNotExists">Выдать ислючение если файл не найден.</param>
        /// <returns></returns>
        public IFile GetFile(Guid fileUniqueID, GetFileOptions loadOptions = null, bool throwIfNotExists = true)
        {
            FileUri fileUri = new FileUri(this.Url, fileUniqueID);
            File    file    = this.TypedStorage.GetFileInternal(fileUri, loadOptions, throwIfNotExists);

            return(file);
        }
Ejemplo n.º 9
0
 internal static Manifest GetFileManifest(FolderUri folder)
 {
     try
     {
         Manifest manifest = null;
         var      file     = new FileUri(folder.UrlFolder, "manifest.json");
         if (file.FileExists)
         {
             string cacheKey = folder.UrlFolder + "manifest.json";
             manifest = (Manifest)DataCache.GetCache(cacheKey);
             if (manifest == null)
             {
                 string content = File.ReadAllText(file.PhysicalFilePath);
                 manifest = JsonConvert.DeserializeObject <Manifest>(content);
                 DataCache.SetCache(cacheKey, manifest, new DNNCacheDependency(file.PhysicalFilePath));
             }
         }
         return(manifest);
     }
     catch (Exception ex)
     {
         Log.Logger.Error($"Failed to load manifest from folder {folder.UrlFolder}. Error: {ex}");
         throw;
     }
 }
Ejemplo n.º 10
0
 private string GenerateListOutput(Page page, TemplateManifest templateManifest, TemplateFiles files, IEnumerable <IDataItem> dataList, string settingsJson)
 {
     if (!string.IsNullOrEmpty(files.Template))
     {
         FileUri templateUri = CheckFiles(templateManifest, files);
         if (dataList != null)
         {
             ModelFactoryMultiple mf = new ModelFactoryMultiple(dataList, settingsJson, _renderinfo.Template.Manifest, _renderinfo.Template, files, _module);
             object model;
             if (templateUri.Extension != ".hbs") // razor
             {
                 model = mf.GetModelAsDynamic();
             }
             else // handlebars
             {
                 if (!App.Services.CreateGlobalSettingsRepository(_module.PortalId).GetLegacyHandlebars())
                 {
                     model = mf.GetModelAsDictionary();
                 }
                 else
                 {
                     model = mf.GetModelAsDynamic();
                 }
             }
             return(ExecuteTemplate(page, templateManifest, files, templateUri, model));
         }
     }
     return("");
 }
Ejemplo n.º 11
0
        private void cmdBuilder_Click(object sender, EventArgs e)
        {
            if (scriptList.SelectedValue.EndsWith("schema.json"))
            {
                var     settings       = ModuleContext.OpenContentSettings();
                FileUri template       = settings.Template.MainTemplateUri();
                string  templateFolder = Path.GetDirectoryName(template.FilePath);
                string  scriptFile     = templateFolder + "/" + scriptList.SelectedValue.Replace("schema.json", "builder.json");
                string  srcFile        = Server.MapPath(scriptFile);

                var schema  = JsonUtils.LoadJsonFromFile(templateFolder + "/" + scriptList.SelectedValue) as JObject;
                var options = JsonUtils.LoadJsonFromFile(templateFolder + "/" + scriptList.SelectedValue.Replace("schema.json", "options.json")) as JObject;

                JObject builder = new JObject();

                if (schema != null && schema["items"] != null)
                {
                    builder["formtype"]   = "array";
                    builder["formfields"] = GetBuilder(schema["items"] as JObject, options != null && options["items"] != null ? options["items"] as JObject : null);
                }
                else
                {
                    builder["formtype"]   = "object";
                    builder["formfields"] = GetBuilder(schema, options);
                }
                if (!File.Exists(srcFile))
                {
                    File.WriteAllText(srcFile, builder.ToString());
                }
                Response.Redirect(Globals.NavigateURL(), true);
            }
        }
Ejemplo n.º 12
0
        private string ExecuteRazor(FileUri template, dynamic model)
        {
            string webConfig = template.PhysicalFullDirectory;

            webConfig = webConfig.Remove(webConfig.LastIndexOf("\\")) + "\\web.config";
            if (!File.Exists(webConfig))
            {
                string filename = HostingEnvironment.MapPath("~/DesktopModules/OpenContent/Templates/web.config");
                File.Copy(filename, webConfig);
            }
            var writer = new StringWriter();

            try
            {
                var razorEngine = new RazorEngine("~/" + template.FilePath, ModuleContext, LocalResourceFile);
                razorEngine.Render(writer, model);
            }
            catch (Exception ex)
            {
                LoggingUtils.RenderEngineException(this, ex);
                string stack = string.Join("\n", ex.StackTrace.Split('\n').Where(s => s.Contains("\\Portals\\") && s.Contains("in")).Select(s => s.Substring(s.IndexOf("in"))).ToArray());
                throw new TemplateException("Failed to render Razor template " + template.FilePath + "\n" + stack, ex, model, template.FilePath);
            }
            return(writer.ToString());
        }
Ejemplo n.º 13
0
        private void cmdCustom_Click(object sender, EventArgs e)
        {
            var settings = ModuleContext.OpenContentSettings();
            TemplateManifest template       = settings.Template;
            string           templateFolder = template.ManifestFolderUri.UrlFolder;
            string           templateDir    = Server.MapPath(templateFolder);
            string           moduleDir      = Server.MapPath(ModuleTemplateDirectory);

            if (!Directory.Exists(moduleDir))
            {
                Directory.CreateDirectory(moduleDir);
            }
            foreach (var item in Directory.GetFiles(moduleDir))
            {
                File.Delete(item);
            }
            foreach (var item in Directory.GetFiles(templateDir))
            {
                File.Copy(item, moduleDir + Path.GetFileName(item));
            }
            ModuleController mc = new ModuleController();

            var newtemplate = new FileUri(ModuleTemplateDirectory, "schema.json");

            mc.UpdateModuleSetting(ModuleId, "template", newtemplate.FilePath);
            ModuleContext.Settings["template"] = newtemplate.FilePath;
            settings = ModuleContext.OpenContentSettings();
            InitEditor(settings.Template);
        }
Ejemplo n.º 14
0
        private void scriptList_SelectedIndexChanged(object sender, EventArgs e)
        {
            FileUri template   = ModuleContext.OpenContentSettings().Template.MainTemplateUri();
            var     scriptFile = new FileUri(template.UrlFolder, scriptList.SelectedValue);

            DisplayFile(scriptFile);
        }
Ejemplo n.º 15
0
        private void DisplayFile(FileUri file)
        {
            lError.Visible = false;
            lError.Text    = "";
            plSource.Text  = file.FilePath;
            string srcFile = file.PhysicalFilePath;

            if (File.Exists(srcFile))
            {
                txtSource.Text = File.ReadAllText(srcFile);
            }
            else
            {
                txtSource.Text = "";
            }
            SetFileType(srcFile);
            cmdBuilder.Visible = scriptList.SelectedValue.EndsWith("schema.json") && scriptList.SelectedValue != "form-schaema.json";
            var    schemaFile = new FileUri(file.FolderPath, "schema.json");
            string schema     = "";

            if (schemaFile.FileExists)
            {
                schema = File.ReadAllText(schemaFile.PhysicalFilePath);
            }
            DotNetNuke.UI.Utilities.ClientAPI.RegisterClientVariable(Page, "schema", schema, true);
        }
Ejemplo n.º 16
0
        private void InitEditor(TemplateManifest template)
        {
            LoadFiles(template);
            var scriptFile = new FileUri(template.ManifestFolderUri.UrlFolder, scriptList.SelectedValue);

            DisplayFile(scriptFile);
        }
Ejemplo n.º 17
0
        private void DisplayFile(FileUri file)
        {
            //string TemplateFolder = template.Directory;
            //TemplateFolder = OpenContentUtils.ReverseMapPath(TemplateFolder);
            //string scriptFile = TemplateFolder + "/" + scriptList.SelectedValue;
            //plSource.Text = scriptFile;
            //string srcFile = Server.MapPath(scriptFile);

            lError.Visible = false;
            lError.Text    = "";
            plSource.Text  = file.FilePath;
            string srcFile = file.PhysicalFilePath;

            if (File.Exists(srcFile))
            {
                txtSource.Text = File.ReadAllText(srcFile);
            }
            else
            {
                txtSource.Text = "";
            }
            SetFileType(srcFile);
            cmdBuilder.Visible = scriptList.SelectedValue.EndsWith("schema.json") && scriptList.SelectedValue != "form-schaema.json";
            var    schemaFile = new FileUri(file.FolderPath, "schema.json");
            string schema     = "";

            if (schemaFile.FileExists)
            {
                schema = File.ReadAllText(schemaFile.PhysicalFilePath);
            }
            DotNetNuke.UI.Utilities.ClientAPI.RegisterClientVariable(Page, "schema", schema, true);
        }
Ejemplo n.º 18
0
        internal static TemplateManifest ToTemplateManifest(this FileUri templateUri)
        {
            TemplateManifest templateManifest;

            GetManifest(new TemplateKey(templateUri), out templateManifest);
            return(templateManifest);
        }
Ejemplo n.º 19
0
        private void GetFiles([NotNull] IEnumerable <ItemHeader> files, [NotNull] GetChildrenDelegate callback)
        {
            Debug.ArgumentNotNull(files, nameof(files));
            Debug.ArgumentNotNull(callback, nameof(callback));

            var result = new List <BaseTreeViewItem>();

            foreach (var child in files)
            {
                var fileUri  = new FileUri(Site, child.Path, child.HasChildren);
                var fileName = ((IItemData)child).GetData("ServerFileName") ?? string.Empty;

                var item = new FileTreeViewItem(fileUri)
                {
                    Text           = child.Name,
                    Updated        = child.Updated,
                    ServerFileName = fileName
                };

                if (child.HasChildren)
                {
                    item.Icon = new Icon("Resources/16x16/folder.png");
                    item.Add(DummyTreeViewItem.Instance);
                }

                result.Add(item);
            }

            callback(result);
        }
Ejemplo n.º 20
0
        public static JObject LoadLocalizationJsonV2(FolderUri templateDir, string culture)
        {
            var     localizationFilename = new FileUri(templateDir, $"localization.{culture}.json");
            JObject localizationJson     = JsonUtils.LoadJsonFromCacheOrDisk(localizationFilename) as JObject;

            return(localizationJson);
        }
Ejemplo n.º 21
0
        public void InvalidateImage(Uri uri)
        {
            string  path         = Path.Combine(this.StorageUri.Uri, Path.GetFileName(uri.AbsolutePath));
            FileUri cacheFileUri = _fileSystem.CreateFileUri(path);

            InvalidateImage(cacheFileUri);
        }
Ejemplo n.º 22
0
        private void NotifyDownloadSubscribers(Uri sourceUri, FileUri localUri, bool success = true)
        {
            _downloading.Remove(sourceUri.AbsoluteUri);

            var subscriptions = _downloadedSubscriptions
                                .Where(s => s.SourceUri.AbsoluteUri == sourceUri.AbsoluteUri)
                                .ToList();

            if (subscriptions == null || subscriptions.Count == 0)
            {
                return;
            }

            foreach (var s in subscriptions)
            {
                if (success)
                {
                    s.Success?.Invoke(localUri);
                }
                else
                {
                    s.Error?.Invoke(localUri);
                }

                _downloadedSubscriptions.Remove(s);
            }
        }
Ejemplo n.º 23
0
        public void InvalidateImage(FileUri imageUri)
        {
            List <int> toRemove = new List <int>();

            foreach (var kvp in _registeredSets)
            {
                if (kvp.Value == imageUri.AbsolutePath)
                {
                    toRemove.Add(kvp.Key);
                }
            }

            if (toRemove.Count > 0)
            {
                foreach (int key in toRemove)
                {
                    UnregisterSetImageForView(key);
                }
            }

            object image = _cache.Remove(imageUri.AbsolutePath);

            if (image != null)
            {
                _loaderPlatform.ReleaseImage(image);
            }
        }
Ejemplo n.º 24
0
        public static string ReadFileFromDisk(FileUri file)
        {
            if (file == null)
            {
                return(null);
            }
            if (!file.FileExists)
            {
                return(null);
            }
            string fileContent;

            try
            {
                fileContent = File.ReadAllText(file.PhysicalFilePath);
                if (string.IsNullOrWhiteSpace(fileContent))
                {
                    return(null);
                }
            }
            catch (Exception ex)
            {
                var mess = $"Error reading file [{file.FilePath}]";
                App.Services.Logger.Error(mess, ex);
                throw new Exception(mess, ex);
            }
            return(fileContent);
        }
Ejemplo n.º 25
0
        protected int LoadFileCache(Dictionary <StringAtom, FileUri> cache, FileUri uri, StringAtom path)
        {
            int     count = 0;
            FileLoc loc;

            loc.uri     = uri;
            loc.modPath = this.ModPath;
            string txt = util.File.LoadTxt(loc, App.Language, path.Str);

            if (txt == null)
            {
                return(0);
            }

            StringReader sr = new StringReader(txt);

            while (true)
            {
                string line = sr.ReadLine();
                if (line == null)
                {
                    break;
                }
                string regline = line.Trim();
                if (!string.IsNullOrEmpty(regline))
                {
                    StringAtom realpath = StringAtom.FromStr(regline);
                    cache[realpath] = uri;
                    ++count;
                }
            }
            sr.Close();
            return(count);
        }
        public int GetHashCode(object obj)
        {
            int hashCode = (ClientRequestId.GetHashCode() + FileUri.GetHashCode() + RelativeUri.GetHashCode() + Started.GetHashCode()) / 4;

            Log.Debug($"hashCode {hashCode}");
            return(hashCode);
        }
Ejemplo n.º 27
0
        private string GenerateOutputSingle(Page page, FileUri template, JToken dataJson, string settingsJson, TemplateFiles files)
        {
            if (template != null)
            {
                if (dataJson != null)
                {
                    ModelFactorySingle mf;

                    if (_renderinfo.Data == null)
                    {
                        // demo data
                        mf = new ModelFactorySingle(_renderinfo.DataJson, settingsJson, _renderinfo.Template.Manifest, _renderinfo.Template, files, _module);
                    }
                    else
                    {
                        mf = new ModelFactorySingle(_renderinfo.Data, settingsJson, _renderinfo.Template.Manifest, _renderinfo.Template, files, _module);
                    }
                    if (template.Extension != ".hbs") // razor
                    {
                        dynamic model = mf.GetModelAsDynamic();
                        if (LogContext.IsLogActive)
                        {
                            var logKey = "Render single item template";
                            LogContext.Log(_module.ViewModule.ModuleId, logKey, "template", template.FilePath);
                            LogContext.Log(_module.ViewModule.ModuleId, logKey, "model", model);
                        }
                        return(ExecuteRazor(template, model));
                    }
                    else // handlebars
                    {
                        object model;
                        if (!App.Services.CreateGlobalSettingsRepository(PortalSettings.Current.PortalId).GetLegacyHandlebars())
                        {
                            model = mf.GetModelAsDictionary();
                        }
                        else
                        {
                            model = mf.GetModelAsDynamic();
                        }
                        if (LogContext.IsLogActive)
                        {
                            var logKey = "Render single item template";
                            LogContext.Log(_module.ViewModule.ModuleId, logKey, "template", template.FilePath);
                            LogContext.Log(_module.ViewModule.ModuleId, logKey, "model", model);
                        }
                        HandlebarsEngine hbEngine = new HandlebarsEngine();
                        return(hbEngine.Execute(page, template, model));
                    }
                }
                else
                {
                    return("");
                }
            }
            else
            {
                return("");
            }
        }
Ejemplo n.º 28
0
 public TemplateManifest GetTemplateManifest(FileUri template)
 {
     if (Templates != null && Templates.ContainsKey(template.FileNameWithoutExtension))
     {
         return(Templates[template.FileNameWithoutExtension]);
     }
     return(null);
 }
Ejemplo n.º 29
0
        public FileUriSelectedObject([NotNull] FileUri fileUri, [NotNull] string serverFileName = "") : base(fileUri.Site)
        {
            Assert.ArgumentNotNull(fileUri, nameof(fileUri));
            Assert.ArgumentNotNull(serverFileName, nameof(serverFileName));

            FileUri        = fileUri;
            ServerFileName = serverFileName;
        }
Ejemplo n.º 30
0
        public static string GetSorterName([NotNull] FileUri fileUri)
        {
            Assert.ArgumentNotNull(fileUri, nameof(fileUri));

            var key = GetKey(fileUri);

            return(AppHost.Settings.GetString("ContentTree\\FileSorting", key, string.Empty));
        }
Ejemplo n.º 31
0
 public void Start(int maxMapperNo, int maxReducerNo, FileUri mapFuncFileName, FileUri reduceFuncFileName, IEnumerable<FileUri> filesToProcess)
 {
     maxMapperNo = filesToProcess.Count();
     this.mapWorkers = this.InitMapThreads(1, maxMapperNo);
     this.keys = this.PerformMap(mapFuncFileName, filesToProcess);
     this.keys = this.keys.Distinct().OrderBy(k => k).ToList();
     this.reduceWorkers = this.InitReduceThreads(maxMapperNo + 1, maxReducerNo);
     var reducersAssignment = this.TransferIntermediateFiles(this.keys);
     this.PerformReduce(reduceFuncFileName, reducersAssignment);
 }
Ejemplo n.º 32
0
        private List<string> PerformMap(FileUri mapFuncFileName, IEnumerable<FileUri> filesToProcess)
        {
            var keys = new List<string>();

            var index = 0;
            foreach (var file in filesToProcess)
            {
                var worker = this.mapWorkers[(index++) % this.mapWorkers.Count];
                worker.Start(BluepathStorage.GetFileNameStatic(file.Uri), BluepathStorage.GetFileNameStatic(mapFuncFileName.Uri));
            }

            for (var i = 0; i < this.mapWorkers.Count; i++)
            {
                this.mapWorkers[i].Join();
            }

            for (var i = 0; i < this.mapWorkers.Count; i++)
            {
                keys.AddRange((IEnumerable<string>)this.mapWorkers[i].Result);
            }

            return keys;
        }
Ejemplo n.º 33
0
        private void PerformReduce(FileUri reduceFuncFileName, Dictionary<string, int> assignments)
        {
            var index = 0;
            foreach (var assignment in assignments)
            {
                var worker = this.reduceWorkers[assignment.Value];
                worker.Start(assignment.Key, BluepathStorage.GetFileNameStatic(reduceFuncFileName.Uri));
            }

            for (var i = 0; i < this.reduceWorkers.Count; i++)
            {
                this.reduceWorkers[i].Join();
            }
        }