예제 #1
0
            /// <summary>
            /// Get all of the dependencies from a workspace
            /// </summary>
            /// <param name="workspace">The workspace to read the dependencies from</param>
            /// <param name="customNodeManager">A custom node manager to look up dependencies</param>
            /// <returns>A WorkspaceDependencies object containing the workspace and its CustomNodeWorkspaceModel dependencies</returns>
            public static WorkspaceDependencies Collect(HomeWorkspaceModel workspace, ICustomNodeManager customNodeManager)
            {
                if (workspace == null) throw new ArgumentNullException("workspace");
                if (customNodeManager == null) throw new ArgumentNullException("customNodeManager");

                // collect all dependencies
                var dependencies = new HashSet<CustomNodeDefinition>();
                foreach (var node in workspace.Nodes.OfType<Function>())
                {
                    dependencies.Add(node.Definition);
                    foreach (var dep in node.Definition.Dependencies)
                    {
                        dependencies.Add(dep);
                    }
                }

                var customNodeWorkspaces = new List<ICustomNodeWorkspaceModel>();
                foreach (var dependency in dependencies)
                {
                    ICustomNodeWorkspaceModel customNodeWs;
                    var workspaceExists = customNodeManager.TryGetFunctionWorkspace(dependency.FunctionId, false, out customNodeWs);

                    if (!workspaceExists)
                    {
                        throw new InvalidOperationException(String.Format(Resources.CustomNodeDefinitionNotFoundErrorMessage, dependency.FunctionName));
                    }

                    if (!customNodeWorkspaces.Contains(customNodeWs))
                    {
                        customNodeWorkspaces.Add(customNodeWs);
                    }
                }

                return new WorkspaceDependencies(workspace, customNodeWorkspaces);
            }
예제 #2
0
        /// <summary>
        /// This recursive function returns true if any of the custom nodes in the input list has an IronPython dependency.
        /// Any custom nodes in the input list traversed during evalution have their dependencies cached in <see cref="CustomNodePythonDependencyMap"/>.
        /// Custom nodes are found to depend on IronPython if the parent custom node or any of its child custom nodes contain an IronPython dependency.
        /// </summary>
        /// <param name="customNodes">The custom nodes to evaluate.</param>
        /// <param name="customNodeManager">The custom node manager.</param>
        /// <returns>True if any IronPython depencies are found, false otherwise.</returns>
        private static bool CustomNodesHaveIronPythonDependency(IEnumerable <Function> customNodes, ICustomNodeManager customNodeManager)
        {
            var hasIronPythonDependency = false;

            foreach (var customNode in customNodes)
            {
                if (!customNodeManager.TryGetFunctionWorkspace(customNode.FunctionSignature, false,
                                                               out ICustomNodeWorkspaceModel customNodeWS))
                {
                    continue;
                }

                // If a custom node workspace is already checked for IronPython dependencies,
                // check the CustomNodePythonDependency dictionary instead of processing it again.
                if (CustomNodePythonDependencyMap.TryGetValue(customNodeWS.CustomNodeId, out CNPythonDependencyType dependency))
                {
                    if (dependency == CNPythonDependencyType.DirectDependency || dependency == CNPythonDependencyType.NestedDependency)
                    {
                        hasIronPythonDependency = true;
                    }
                    continue;
                }

                var hasPythonNodesInCustomNodeWorkspace = customNodeWS.Nodes.Any(n => IsIronPythonNode(n));

                if (hasPythonNodesInCustomNodeWorkspace)
                {
                    CustomNodePythonDependencyMap.Add(customNodeWS.CustomNodeId, CNPythonDependencyType.DirectDependency);
                    hasIronPythonDependency = true;
                }
                else
                {
                    CustomNodePythonDependencyMap.Add(customNodeWS.CustomNodeId, CNPythonDependencyType.NoDependency);
                }

                // Recursively check for IronPython dependencies in the nested custom nodes.
                var nestedCustomNodes = customNodeWS.Nodes.OfType <Function>();

                if (nestedCustomNodes.Any())
                {
                    hasPythonNodesInCustomNodeWorkspace = CustomNodesHaveIronPythonDependency(nestedCustomNodes, customNodeManager);

                    // If a custom node contains an IronPython dependency in its sub-tree,
                    // update its corresponding value to 'NestedDependency' in CustomNodePythonDependency.
                    if (hasPythonNodesInCustomNodeWorkspace && CustomNodePythonDependencyMap[customNodeWS.CustomNodeId] != CNPythonDependencyType.DirectDependency)
                    {
                        CustomNodePythonDependencyMap[customNodeWS.CustomNodeId] = CNPythonDependencyType.NestedDependency;
                        hasIronPythonDependency = true;
                    }
                }
            }

            return(hasIronPythonDependency);
        }
예제 #3
0
        public bool SetPath(string originalPath, string newDirectoryPath)
        {
            var id = customNodeManager.GuidFromPath(originalPath);

            CustomNodeWorkspaceModel def;
            var res = customNodeManager.TryGetFunctionWorkspace(id, this.isTestMode, out def);

            if (!res)
            {
                return(false);
            }

            var newPath = Path.Combine(newDirectoryPath, Path.GetFileName(def.FileName));

            def.FileName = newPath;

            return(true);
        }
예제 #4
0
            /// <summary>
            /// Get all of the dependencies from a workspace
            /// </summary>
            /// <param name="workspace">The workspace to read the dependencies from</param>
            /// <param name="customNodeManager">A custom node manager to look up dependencies</param>
            /// <returns>A WorkspaceDependencies object containing the workspace and its CustomNodeWorkspaceModel dependencies</returns>
            public static WorkspaceDependencies Collect(HomeWorkspaceModel workspace, ICustomNodeManager customNodeManager)
            {
                if (workspace == null)
                {
                    throw new ArgumentNullException("workspace");
                }
                if (customNodeManager == null)
                {
                    throw new ArgumentNullException("customNodeManager");
                }

                // collect all dependencies
                var dependencies = new HashSet <CustomNodeDefinition>();

                foreach (var node in workspace.Nodes.OfType <Function>())
                {
                    dependencies.Add(node.Definition);
                    foreach (var dep in node.Definition.Dependencies)
                    {
                        dependencies.Add(dep);
                    }
                }

                var customNodeWorkspaces = new List <ICustomNodeWorkspaceModel>();

                foreach (var dependency in dependencies)
                {
                    ICustomNodeWorkspaceModel customNodeWs;
                    var workspaceExists = customNodeManager.TryGetFunctionWorkspace(dependency.FunctionId, false, out customNodeWs);

                    if (!workspaceExists)
                    {
                        throw new InvalidOperationException(String.Format(Resources.CustomNodeDefinitionNotFoundErrorMessage, dependency.FunctionName));
                    }

                    if (!customNodeWorkspaces.Contains(customNodeWs))
                    {
                        customNodeWorkspaces.Add(customNodeWs);
                    }
                }

                return(new WorkspaceDependencies(workspace, customNodeWorkspaces));
            }
예제 #5
0
        public bool SetPath(string originalPath, string newDirectoryPath)
        {
            var id = customNodeManager.GuidFromPath(originalPath);

            ICustomNodeWorkspaceModel def;
            var res = customNodeManager.TryGetFunctionWorkspace(id, this.isTestMode, out def);

            if (!res)
            {
                return(false);
            }

            var newPath = Path.Combine(newDirectoryPath, Path.GetFileName(def.FileName));

            // TODO: http://adsk-oss.myjetbrains.com/youtrack/issue/MAGN-7989
            var cdef = def as CustomNodeWorkspaceModel;

            cdef.FileName = newPath;

            return(true);
        }
예제 #6
0
        /// <summary>
        /// Sends workspace and its' dependencies to Flood.
        /// </summary>
        /// <returns>String which is response from server.</returns>
        internal string Send(IEnumerable <IWorkspaceModel> workspaces, WorkspaceProperties workspaceProperties = null)
        {
            if (String.IsNullOrWhiteSpace(serverUrl))
            {
                Error = UploadErrorType.ServerNotFound;
                return(Resources.FailedMessage);
            }

            if (String.IsNullOrWhiteSpace(authenticationProvider.Username))
            {
                Error = UploadErrorType.AuthenticationFailed;
                return(Resources.FailedMessage);
            }

            if (authenticationProvider == null)
            {
                Error = UploadErrorType.AuthProviderNotFound;
                return(Resources.FailedMessage);
            }

            if (reachClient == null)
            {
                reachClient = new WorkspaceStorageClient(authenticationProvider, serverUrl);
            }

            HomeWorkspace = workspaces.OfType <HomeWorkspaceModel>().First();
            var functionNodes = HomeWorkspace.Nodes.OfType <Function>();

            List <CustomNodeDefinition> dependencies = new List <CustomNodeDefinition>();

            foreach (var node in functionNodes)
            {
                dependencies.AddRange(node.Definition.Dependencies);
            }

            CustomNodeWorkspaces = new List <ICustomNodeWorkspaceModel>();
            foreach (var dependency in dependencies)
            {
                ICustomNodeWorkspaceModel customNodeWs;
                var isWorkspaceCreated = customNodeManager.TryGetFunctionWorkspace(dependency.FunctionId, false, out customNodeWs);
                if (isWorkspaceCreated && !CustomNodeWorkspaces.Contains(customNodeWs))
                {
                    CustomNodeWorkspaces.Add(customNodeWs);
                }
            }

            string result;

            try
            {
                result = reachClient.Send(
                    HomeWorkspace,
                    CustomNodeWorkspaces.OfType <CustomNodeWorkspaceModel>(),
                    workspaceProperties);
                InvalidNodeNames = null;
            }
            catch (InvalidNodesException ex)
            {
                InvalidNodeNames = ex.InvalidNodeNames;
                result           = Resources.FailedMessage;
            }
            catch
            {
                result = Resources.FailedMessage;
            }

            return(result);
        }