c# access visualsvn server, according to its mof file, control its server-side functions, such as building user access rights

https://yq.aliyun.com/articles/15964

Summary: VisualSVN Server can use WMI interface management (Windows Management Instrumentation). The interface is described in the MOF file located under %VISUALSVN_SERVER%\WMI on the computer where VisualSVN Server is installed.


VisualSVN Server can be managed using the WMI interface (Windows Management Instrumentation).
The interface is described in the MOF file located under %VISUALSVN_SERVER%\WMI on the computer where VisualSVN Server is installed. VisualSVN Server can be managed with C# code control.

My machine VisualSVN is installed on the D drive, and the MOF file exists in the location: D:\Program Files\VisualSVN Server\WMI\VisualSVNServer.mof

Here are some codes for reference:


using System.Management;
using System.Management.Instrumentation;

And add System.Management, System.Management.Instrumentation references to these two components.

1) Create Subversion user 'user1' with password 'secret'


ManagementClass userClass = newManagementClass("root\\VisualSVN","VisualSVN_User",null);
// Obtain in-parameters for the method
ManagementBaseObject inParams =
userClass.GetMethodParameters("Create");
// Add the input parameters.
inParams["Name"] = "user1";
inParams["Password"] = "secret";
// Execute the method and obtain the return values.
ManagementBaseObject outParams =
userClass.InvokeMethod("Create", inParams, null);

 2) Create a new repository 'Repo1'


ManagementClass repoClass = newManagementClass("root\\VisualSVN","VisualSVN_Repository",null);
// Obtain in-parameters for the method
ManagementBaseObject inParams =
repoClass.GetMethodParameters("Create");
// Add the input parameters.
inParams["Name"] = "Repo1";
// Execute the method and obtain the return values.
ManagementBaseObject outParams =
repoClass.InvokeMethod("Create", inParams, null);




  3) Set SID S-1-5-32-545 ('BUILTIN\Users') Windows user group to read/write permission to 'Test' repository. FYI: AccessLevel value is described in MOF: "0 - no permission, 1 - read only, 2 - read/write".


ManagementClass userClass = newManagementClass("root\\VisualSVN","VisualSVN_WindowsAccount",null);
ManagementClass authzClass = newManagementClass("root\\VisualSVN","VisualSVN_SecurityDescriptor",null);
ManagementClass permClass = newManagementClass("root\\VisualSVN","VisualSVN_PermissionEntry",null);
ManagementObject userObject = userClass.CreateInstance();
userObject.SetPropertyValue("SID","S-1-5-32-545");
ManagementObject permObject = permClass.CreateInstance();
permObject.SetPropertyValue("Account", userObject);
permObject.SetPropertyValue("AccessLevel", 2);
ManagementObject repo = newManagementObject("VisualSVN_Repository.Name='Test'");
ManagementBaseObject inParams =
authzClass.GetMethodParameters("SetSecurity");
inParams["Object"] = repo;
inParams["Permissions"] = newobject[] { permObject };
ManagementBaseObject outParams =
authzClass.InvokeMethod("SetSecurity", inParams, null);

The encapsulated Helper class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;//Calling windows WMI needs to import such a library

namespace Whir.Software.InteralServerManage.SVNManager
{
    /// <summary>
    /// Visual SVN operation auxiliary class: use WMI to control VisualSVN, the MOF file exists in the location: C:\Program Files\VisualSVN Server\WMI\VisualSVNServer.mof
    /// </summary>
    public class SVNHelper
    {
        #region settings

        #region Set warehouse permissions

        public enum AccessLevel : uint
        {
            NoAccess = 0,
            ReadOnly,
            ReadWrite
        }

        /// <summary>
        /// Set warehouse permissions (authorize users)
        /// </summary>
        /// <param name="userName">username</param>
        /// <param name="repository">SVN repository</param>
        public static bool SetRepositoryPermission(string userName, string repository)
        {
            return SetRepositoryPermission(userName, repository, 2);
        }

        /// <summary>
        /// Set warehouse permissions (authorize users)
        /// </summary>
        /// <param name="users">username</param>
        /// <param name="repository">SVN repository</param>
        public static bool SetRepositoryPermission(List<string> users, string repository)
        {
            string userNames = "";
            foreach (string user in users)
            {
                userNames += user + ",";
            }
            return SetRepositoryPermission(userNames, repository, 2);
        }

        /// <summary>
        /// Set warehouse permissions (authorize users)
        /// </summary>
        /// <param name="userName">username</param>
        /// <param name="repository">SVN repository</param>
        /// <param name="permission"> Permission code: 0 deny, 1 read only, 2 read and write</param>
        public static bool SetRepositoryPermission(string userName, string repository, int permission)
        {
            try
            {
                string[] users = userName.Split(new[] {","}, StringSplitOptions.RemoveEmptyEntries);
                IDictionary<string, AccessLevel> permissions = GetPermissions(repository, "/");
                foreach (string s in users)
                {
                    if (!permissions.ContainsKey(s))
                    {
                        permissions.Add(s, AccessLevel.ReadWrite);
                    }
                }
                SetPermissions(repository, "/", permissions);
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// Get the warehouse entity according to the warehouse name
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        private static ManagementObject GetRepositoryObject (string name)
        {
            return new ManagementObject("root\\VisualSVN", string.Format("VisualSVN_Repository.Name='{0}'", name), null);
        }

        /// <summary>
        /// Read permission entity
        /// </summary>
        /// <param name="sid"></param>
        /// <param name="accessLevel"></param>
        /// <returns></returns>
        private static ManagementObject GetPermissionObject(string sid, AccessLevel accessLevel)
        {
            var accountClass = new ManagementClass("root\\VisualSVN",
                                                   "VisualSVN_WindowsAccount", null);
            var entryClass = new ManagementClass("root\\VisualSVN",
                                                 "VisualSVN_PermissionEntry", null);
            ManagementObject account = accountClass.CreateInstance();
            if (account != null) account["SID"] = sid;
            ManagementObject entry = entryClass.CreateInstance();
            if (entry != null)
            {
                entry["AccessLevel"] = accessLevel;
                entry["Account"] = account;
                return entry;
            }
            return null;
        }

        /// <summary>
        /// Set repository permissions
        /// </summary>
        /// <param name="repositoryName"></param>
        /// <param name="path"></param>
        /// <param name="permissions"></param>
        private static void SetPermissions(string repositoryName, string path,
                                           IEnumerable<KeyValuePair<string, AccessLevel>> permissions)
        {
            ManagementObject repository = GetRepositoryObject (repositoryName);
            ManagementBaseObject inParameters = repository.GetMethodParameters("SetSecurity");
            inParameters["Path"] = path;
            IEnumerable<ManagementObject> permissionObjects =
                permissions.Select(p => GetPermissionObject(p.Key, p.Value));
            inParameters["Permissions"] = permissionObjects.ToArray();
            repository.InvokeMethod("SetSecurity", inParameters, null);
        }

        /// <summary>
        /// Read repository permission
        /// </summary>
        /// <param name="repositoryName"></param>
        /// <param name="path"></param>
        /// <returns></returns>
        private static IDictionary<string, AccessLevel> GetPermissions(string repositoryName, string path)
        {
            ManagementObject repository = GetRepositoryObject (repositoryName);
            ManagementBaseObject inParameters = repository.GetMethodParameters("GetSecurity");
            inParameters["Path"] = path;
            ManagementBaseObject outParameters = repository.InvokeMethod("GetSecurity", inParameters, null);

            var permissions = new Dictionary<string, AccessLevel>();

            if (outParameters != null)
                foreach (ManagementBaseObject p in (ManagementBaseObject[]) outParameters["Permissions"])
                {
                    // NOTE: This will fail if VisualSVN Server is configured to use Subversion
                    // authentication.  In that case you'd probably want to check if the account
                    // is a VisualSVN_WindowsAccount or a VisualSVN_SubversionAccount instance
                    // and tweak the property name accordingly.
                    var account = (ManagementBaseObject) p["Account"];
                    var sid = (string) account["SID"];
                    var accessLevel = (AccessLevel) p["AccessLevel"];

                    permissions[sid] = accessLevel;
                }

            return permissions;
        }

        #endregion

        #region Create user group

        /// <summary>
        /// Create a user group
        /// </summary>
        public static bool CreatGroup(string groupName)
        {
            try
            {
                var svn = new ManagementClass("root\\VisualSVN", "VisualSVN_Group", null);
                ManagementBaseObject @params = svn.GetMethodParameters("Create");
                @params["Name"] = groupName.Trim();
                @params["Members"] = new object[] {};
                svn.InvokeMethod("Create", @params, null);
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        #endregion

        #region create user

        /// <summary>
        /// Create user
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        public static bool CreateUser(string userName, string password)
        {
            try
            {
                var svn = new ManagementClass("root\\VisualSVN", "VisualSVN_User", null);
                ManagementBaseObject @params = svn.GetMethodParameters("Create");
                @params["Name"] = userName.Trim();
                @params["Password"] = password.Trim();
                svn.InvokeMethod("Create", @params, null);
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        #endregion

        #region create svn repository

        /// <summary>
        /// Create svn repository
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public static bool CreateRepository(string name)
        {
            try
            {
                var svn = new ManagementClass("root\\VisualSVN", "VisualSVN_Repository", null);
                ManagementBaseObject @params = svn.GetMethodParameters("Create"); //Create method parameter reference
                @params["Name"] = name.Trim(); //Incoming parameters
                svn.InvokeMethod("Create", @params, null); //执行
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        #endregion

        #region Create svn repository directory

        /// <summary>
        /// Create svn repository directory
        /// </summary>
        /// <param name="repositories"> </param>
        /// <param name="name"></param>
        /// <returns></returns>
        public static bool CreateRepositoryFolders(string repositories, string[] name)
        {
            try
            {
                var repository = new ManagementClass("root\\VisualSVN", "VisualSVN_Repository", null);
                ManagementObject repoObject = repository.CreateInstance();
                if (repoObject != null)
                {
                    repoObject.SetPropertyValue("Name", repositories);
                    ManagementBaseObject inParams = repository.GetMethodParameters("CreateFolders");
                    inParams["Folders"] = name;
                    inParams["Message"] = "";
                    repoObject.InvokeMethod("CreateFolders", inParams, null);
                }
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        #endregion

        //public static bool SetMemberGroup(string userName, string groupName)
        //{
        //    try
        //    {
        //        var userObj = GetGroupUsersArr(groupName);
        //        foreach (ManagementBaseObject baseObject in userObj)
        //        {
        //            if (baseObject["Name"].ToString().ToLower() == userName)
        //            {
        //                return false;
        //            }
        //        }
        //        var addUser = new ManagementClass("root\\VisualSVN", "VisualSVN_SubversionAccount", null).CreateInstance();
        //        if (addUser != null)
        //        {
        //            addUser.SetPropertyValue("Name", userName);
        //            userObj.Add(addUser);
        //        }

        //        var svnUser = new ManagementClass("root\\VisualSVN", "VisualSVN_Group", null);
        //        ManagementBaseObject inParams = svnUser.GetMethodParameters("SetMembers");
        //        inParams["Members"] = new object[] { userObj };
        //        svnUser.InvokeMethod("SetMembers", inParams, null);
        //        return true;
        //    }
        //    catch (Exception)
        //    {
        //        return false;
        //    }
        //}

        #endregion

        #region read

        /// <summary>
        /// Read the users in the specified group
        /// </summary>
        /// <param name="groupName"></param>
        /// <returns></returns>
        public static List<string> GetGroupUsers(string groupName)
        {
            var listUsers = new List<string>();
            var group = new ManagementClass("root\\VisualSVN", "VisualSVN_Group", null);
            ManagementObject instance = group.CreateInstance();
            if (instance != null)
            {
                instance.SetPropertyValue("Name", groupName.Trim());
                ManagementBaseObject outParams = instance.InvokeMethod("GetMembers", null, null); //Invoke the method through the instance
                if (outParams != null)
                {
                    var members = outParams["Members"] as ManagementBaseObject[];
                    if (members != null)
                    {
                        foreach (ManagementBaseObject member in members)
                        {
                            object name = member["Name"];
                            listUsers.Add(name.ToString());
                        }
                    }
                }
            }
            return listUsers;
        }

        public static List<ManagementBaseObject> GetGroupUsersArr(string groupName)
        {
            var list = new List<ManagementBaseObject>();
            var group = new ManagementClass("root\\VisualSVN", "VisualSVN_Group", null);
            ManagementObject instance = group.CreateInstance();
            if (instance != null)
            {
                instance.SetPropertyValue("Name", groupName.Trim());
                ManagementBaseObject outParams = instance.InvokeMethod("GetMembers", null, null); //Invoke the method through the instance
                if (outParams != null)
                {
                    var members = outParams["Members"] as ManagementBaseObject[];
                    if (members != null)
                    {
                        foreach (ManagementBaseObject member in members)
                        {
                            list.Add(member);
                        }
                    }
                }
            }
            return list;
        }

        #endregion
    }
}