コード例 #1
0
        //private static Constants.ResourceType? listType;
        static int Main(string[] args)
        {
            Parser parser = new Parser(settings =>
            {
                settings.CaseSensitive = false;
                // settings.IgnoreUnknownArguments = false;
            });
            PrintTable table = new PrintTable {
                { Constants.HeaderStringType, 6 },
                { Constants.HeaderStringNameOfResource, 21 },
                { Constants.HeaderStringVersion, 16 },
                { Constants.HeaderStringFileSize, 11 },
            };

            if (args.ToList().Count == 0)
            {
                Logger.logError($"{Constants.APPLICATION_ALIAS} must be called with an action name. Available actions:");
                GetOptions.GetAllOptions();
                return(0);
            }

            return(CommandLine.Parser.Default.ParseArguments <InitOptions, AddOptions, ListOptions, AvailableOptions,
                                                              DependencyOption, PublishOptions, RemoveOptions>(args.ToList())
                   .MapResult(
                       (InitOptions opts) => InitOptions.initDirectories(),
                       (AddOptions opts) => AddOptions.AddPackage(args.ToList()),
                       (ListOptions opts) => ListOptions.ListResources(opts.resourceType, args.ToList()),
                       (AvailableOptions opts) => AvailableOptions.Available(),
                       (DependencyOption opts) => DependencyOption.ListAllDependencies(args.ToList()),
                       (PublishOptions opts) => PublishOptions.Publish(args.ToList()),
                       (RemoveOptions opts) => RemoveOptions.RemovePackage(args.ToList()),
                       errs => 1));
        }
コード例 #2
0
        public static void remove(ResourceIdentifier resourceDescription)
        {
            try
            {
                string resourceName = resourceDescription.resourceName;
                // Console.WriteLine(resourceName);
                ResourceType resourceType = resourceDescription.resourceType;
                // Console.WriteLine(resourceType);
                InitOptions.initDirectories();

                Logger.logLine($"Removing {resourceType.ToString().ToLower()} resource \"{resourceName}\"");
                if (!ResourceTypes.resourceFileExists(resourceType, resourceName))
                {
                    Logger.logError($"{resourceType} resource \"{resourceName}\" does not exist");
                    return;
                }

                if (resourceDescription.version != null)
                {
                    if (ResourceTypes.resourceVersionFileExists(resourceType, resourceName))
                    {
                        string localVersion = ResourceTypes.getResourceVersion(resourceType, resourceName);
                        if (localVersion != resourceDescription.version)
                        {
                            bool removeAnyways = Logger.askYesOrNo($"Present version is {localVersion}, not {resourceDescription.version}. Remove anyways?");
                            if (!removeAnyways)
                            {
                                Logger.logLine("Aborting resource removal.");
                                return;
                            }
                        }
                    }
                    else
                    {
                        bool removeAnyways = Logger.askYesOrNo($"Local file {resourceName} has unknown version. Remove anyways?");
                        if (!removeAnyways)
                        {
                            Logger.logLine("Aborting resource removal.");
                            return;
                        }
                    }
                }

                ResourceTypes.removeResourceFilesIfPresent(resourceType, resourceName);
                Logger.logLine("Resource removed");
            }
            catch (Exception ex)
            {
                Logger.logError($"File System Error: " + ex.Message);
            }
        }
コード例 #3
0
        public static void Add_Package(string prefix, ResourceIdentifier resourceDescription)
        {
            try
            {
                ResourceType resourceType = resourceDescription.resourceType;
                string       resourceName = resourceDescription.resourceName;

                // check if the resource is available from the server
                var availableResources = NetworkUtils.getAvailableResources(prefix, resourceType);
                if (!availableResources.resourceDescriptions.ContainsKey(resourceName))
                {
                    Logger.logError($"No resource called {resourceName} is available from the server.");
                    return;
                }

                string version           = resourceDescription.version; // possible null
                var    serverVersionInfo = NetworkUtils.getResourceVersions(prefix, resourceType, resourceName);

                if (version == null)
                {
                    version = serverVersionInfo.latestVersion;
                }
                else
                {
                    // check that the requested version is available from the server
                    if (!serverVersionInfo.versions.ContainsKey(version))
                    {
                        Logger.logError(
                            $"There is no version {version} available of resource {resourceName}. " +
                            $"These are the version(s) available: {string.Join(", ", serverVersionInfo.versions.Keys.ToList())}"
                            );
                        return;
                    }
                }

                // check if nyoka directories exists
                if (!ResourceTypes.hasNecessaryDirs())
                {
                    bool createDirs = Logger.askYesOrNo(
                        "Resource directories are not present in this directory. Create them now?"
                        );

                    if (createDirs)
                    {
                        InitOptions.tryCreateDirIfNonExistent();
                    }
                    else
                    {
                        Logger.logLine("Package add aborted");
                        return;
                    }
                }

                // check if the resource is already present
                if (ResourceTypes.resourceFileExists(resourceType, resourceName))
                {
                    bool continueAnyways = Logger.askYesOrNo(
                        $"{resourceType.ToString()} resource {resourceName} is already present. Delete and replace ?"
                        );

                    if (continueAnyways)
                    {
                        ResourceTypes.removeResourceFilesIfPresent(resourceType, resourceName);
                    }
                    else
                    {
                        Logger.logLine("Aborting resource add.");
                        return;
                    }
                }

                ResourceDependencyInfoContainer dependencies = NetworkUtils.getResourceDependencies(prefix, resourceType, resourceName, version);

                var depDescriptions = new Dictionary <ResourceType, Dictionary <string, ResourceDependencyInfoContainer.DependencyDescription> > {
                    { ResourceType.Code, dependencies.codeDeps },
                    { ResourceType.Data, dependencies.dataDeps },
                    { ResourceType.Model, dependencies.modelDeps },
                };

                bool downloadDependencies = false;

                // if there package has any dependencies
                if (depDescriptions.Any(kvPair => kvPair.Value.Count != 0))
                {
                    PrintTable table = new PrintTable {
                        { "Resource Type", 13 },
                        { "Dependency Type", 15 },
                        { "Name of Resource", 16 },
                        { "Resource Version", 16 },
                        { "File Size", 9 },
                    };

                    foreach (var(depResourceType, deps) in depDescriptions.Select(x => (x.Key, x.Value)))
                    {
                        foreach (var(depName, depDescription) in deps.Select(x => (x.Key, x.Value)))
                        {
                            table.addRow(
                                depResourceType.ToString(),
                                depDescription.isDirectDependency ? "direct" : "indirect",
                                depName,
                                depDescription.versionStr,
                                ResourceTypes.bytesToString(depDescription.byteCount)
                                );
                        }
                    }

                    Logger.logLine($"Resource {resourceName} has these dependencies:");
                    Logger.logTable(table);
                    downloadDependencies = Logger.askYesOrNo("Download these dependencies?");

                    if (downloadDependencies)
                    {
                        Logger.logLine("Downloading dependencies");
                    }
                    else
                    {
                        Logger.logLine("Skipping downloading dependencies.");
                    }
                }

                if (downloadDependencies)
                {
                    var depsToDownload = new List <(ResourceType, string, string)>();
                    foreach (var(depResourceType, deps) in depDescriptions.Select(x => (x.Key, x.Value)))
                    {
                        foreach (var(depName, depDescription) in deps.Select(x => (x.Key, x.Value)))
                        {
                            bool continueWithDownload = true;

                            // Ask user whether to overwrite file if a file with this name exists locally already
                            if (ResourceTypes.resourceFileExists(depResourceType, depName))
                            {
                                if (ResourceTypes.resourceVersionFileExists(depResourceType, depName))
                                {
                                    string depLocalVersion = ResourceTypes.getResourceVersion(depResourceType, depName);

                                    if (depDescription.versionStr == depLocalVersion)
                                    {
                                        continueWithDownload = Logger.askYesOrNo(
                                            $"Dependency {depName} file exists locally at the required version " +
                                            $"({depDescription.versionStr}). Overwrite this file?"
                                            );
                                    }
                                    else
                                    {
                                        continueWithDownload = Logger.askYesOrNo(
                                            $"Dependency {depName} file exists locally at version {depLocalVersion}" +
                                            $" (depency required version is {depDescription.versionStr}). Overwrite this file?"
                                            );
                                    }
                                }
                                else
                                {
                                    continueWithDownload = Logger.askYesOrNo(
                                        $"Dependency {depName} file exists locally at an unknown version. Overwrite this file?"
                                        );
                                }
                            }

                            if (continueWithDownload)
                            {
                                depsToDownload.Add((depResourceType, depName, depDescription.versionStr));
                            }
                            else
                            {
                                Logger.logWarning($"Skipping download of dependency {depName}.");
                            }
                        }
                    }

                    foreach (var(depResourceType, depName, depVersion) in depsToDownload)
                    {
                        downloadPackage(prefix, depResourceType, depName, depVersion);
                    }
                }

                downloadPackage(prefix, resourceType, resourceName, version);
            }
            catch (NetworkUtils.NetworkUtilsException ex)
            {
                Logger.logError($"Network Error: {ex.Message}");
            }
            catch (Exception ex)
            {
                Logger.logError($"File System Error: " + ex.Message);
            }
        }