public virtual void InstallTools(Dictionary <string, string> packages) { // install foreach (var id in packages.Keys) { var toolPackage = id; var toolPackageVersion = packages[id]; MetaPackTrace.Verbose(string.Format("Resolving tool:[{0}] version:[{1}]", toolPackage, toolPackageVersion)); IPackage localPackage = null; if (!string.IsNullOrEmpty(toolPackageVersion)) { localPackage = ToolPackageManager.LocalRepository.FindPackage(toolPackage, new SemanticVersion(toolPackageVersion)); } else { localPackage = ToolPackageManager.LocalRepository.FindPackage(toolPackage); } if (localPackage == null) { MetaPackTrace.Verbose(string.Format("Tool package does not exist locally. Installing...")); IntallToolPackage(toolPackage, toolPackageVersion); } else { if (!ForceInstallPackages) { MetaPackTrace.Verbose(string.Format("Tool exists. No need for install")); } else { // force install, kinda debug thing MetaPackTrace.Verbose(string.Format(".ForceInstallPackages is true. Uninstalling existing package.")); ToolPackageManager.UninstallPackage(localPackage, true); MetaPackTrace.Verbose(string.Format("Installing...")); IntallToolPackage(toolPackage, toolPackageVersion); } } } }
protected virtual void InitPackageManager() { Directory.CreateDirectory(ToolPath); var repo = new AggregateRepository(PackageRepositoryFactory.Default, PackageSources, true); toolPackageManager = new PackageManager( repo, new DefaultPackagePathResolver("https://packages.nuget.org/api/v2"), new PhysicalFileSystem(ToolPath) ); toolPackageManager.PackageInstalling += (s, e) => { MetaPackTrace.Info("Installing tool [{0}] version [{1}]", e.Package.Id, e.Package.Version); }; toolPackageManager.PackageInstalled += (s, e) => { MetaPackTrace.Info("Installed tool [{0}] version [{1}]", e.Package.Id, e.Package.Version); }; }
public override Stream Pack(SolutionPackageBase package, SolutionPackageOptions options) { var typedPackage = package; MetaPackTrace.Verbose("Packing solution package..."); // create result stream and NuGet package var resultStream = new MemoryStream(); var metadata = GetManifestMetadata(package); var nugetPackageBuilder = new PackageBuilder(); var solutionPackageManifestFile = new ManifestFile(); var solutionFilePath = SaveMetaPackSolutionFile <SolutionPackageBase>(solutionPackageManifestFile, typedPackage); nugetPackageBuilder.PopulateFiles("", new[] { solutionPackageManifestFile }); nugetPackageBuilder.Populate(metadata); // TODO // implement container persistance var models = package.GetModels(); foreach (var model in models) { var modelManifestFile = GetModelManifestFile(model); nugetPackageBuilder.PopulateFiles("", new[] { modelManifestFile }); } // save nuget package into the final stream nugetPackageBuilder.Save(resultStream); resultStream.Position = 0; MetaPackTrace.Verbose("Packing solution package completed..."); return(resultStream); }
public virtual void WithSharePointContext( string url, string userName, string userPassword, bool isSharePointOnline, Action <ClientContext> action) { MetaPackTrace.Info("Connecting to SharePoint web site:[{0}]", url); using (var context = new ClientContext(url)) { if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(userPassword)) { MetaPackTrace.Info("Using username:[{0}]", userName); var securePassword = new SecureString(); foreach (var c in userPassword) { securePassword.AppendChar(c); } if (isSharePointOnline) { MetaPackTrace.Info("Using O365 runtime and SharePointOnlineCredentials"); context.Credentials = new SharePointOnlineCredentials(userName, securePassword); } else { MetaPackTrace.Info("Using SP2013 runtime and NetworkCredential"); context.Credentials = new NetworkCredential(userName, securePassword); } } action(context); } }
protected virtual void OnPackageInstalling(object sender, PackageOperationEventArgs e) { MetaPackTrace.Info("NuGet package installation started"); MetaPackTrace.Info("Package [{0}] version [{1}]", e.Package.Id, e.Package.Version); // save pachage to a local folder // cause package can't be serialized to be passed to a new app domain var tmpPackageFilePath = SavePackageAsTempFile(e.Package); MetaPackTrace.Info("Resolving solution tool package..."); var toolPackage = ResolveSolutionToolPackage(e.Package); if (toolPackage == null || string.IsNullOrEmpty(toolPackage.Id)) { throw new MetaPackException("Cannot resolve solution tool package"); } MetaPackTrace.Info("Resolved solution tool package [{0}] version:[{1}]", toolPackage.Id, toolPackage.Version); // install main tool package var toolResolver = MetaPackServiceContainer.Instance.GetService <ToolResolutionService>(); if (toolResolver == null) { toolResolver = new ToolResolutionService(); } var toolRepo = toolResolver.ToolPackageManager.LocalRepository; MetaPackTrace.Info("Installing solution tool package..."); foreach (var packageSource in toolResolver.PackageSources) { MetaPackTrace.Verbose(string.Format(" - using repo:[{0}]", packageSource)); } toolResolver.ForceInstallPackages = ForceInstallToolPackages; toolResolver.InstallTool(toolPackage); MetaPackTrace.Info("Resolving additional tooling for tool package [{0}]", toolPackage.Id); // resolve main assembly, resolve additional tooling var toolNuGetPackage = toolResolver.ToolPackageManager.LocalRepository.FindPackage(toolPackage.Id); var assemblyHint = toolPackage.AssemblyNameHint ?? toolPackage.Id + ".dll"; var additionalTools = toolResolver.ResolveAdditionalTooling(toolRepo, toolNuGetPackage, assemblyHint); if (additionalTools.Count > 0) { MetaPackTrace.Info("Found [{0}] additional tools", additionalTools.Count); foreach (var tool in additionalTools) { MetaPackTrace.Info(" Tool [{0}] version:[{1}]", tool.Id, tool.Version); } MetaPackTrace.Info("Installing additional tools..."); toolResolver.InstallTools(additionalTools); MetaPackTrace.Info("Installing additional tools completed"); } else { MetaPackTrace.Info("No additional tools were found"); } // resolve package and deployment classes // by default lookup firs implementations of the following classes: // * SolutionPackageServiceBase // * SolutionPackageDeploymentServiceBase MetaPackTrace.Info("Resolving solution packaging implemetation"); var packagingServiceClassFullName = toolResolver.ResolveClassImplementationFullName(toolRepo, toolNuGetPackage, assemblyHint, typeof(SolutionPackageServiceBase).Name); if (string.IsNullOrEmpty(packagingServiceClassFullName)) { throw new MetaPackException(string.Format("Cannot find impl for service:[{0}]", typeof(SolutionPackageServiceBase).Name)); } MetaPackTrace.Info("Resolved solution tool implemetation:[{0}]", packagingServiceClassFullName); MetaPackTrace.Info("Resolving solution deployment implemetation"); var deploymentServiceFullName = toolResolver.ResolveClassImplementationFullName(toolRepo, toolNuGetPackage, assemblyHint, typeof(SolutionPackageDeploymentServiceBase).Name); if (string.IsNullOrEmpty(deploymentServiceFullName)) { throw new MetaPackException(string.Format("Cannot find impl for service:[{0}]", typeof(SolutionPackageDeploymentServiceBase).Name)); } MetaPackTrace.Info("Resolved solution deployment implemetation:[{0}]", deploymentServiceFullName); var toolAssemblies = toolResolver.ResolveAssemblyPaths(toolRepo, toolNuGetPackage, "net45", false); var toolAssembly = toolAssemblies.FirstOrDefault(a => a.EndsWith(assemblyHint)); MetaPackTrace.Verbose("Current AppDomain.ID:[{0}]", AppDomain.CurrentDomain.Id); MetaPackTrace.Info("Unpacking solution package..."); using (var context = AppDomainContext.Create()) { var detectedAdditionalToolAssemblies = new List <string>(); var detectedAdditionalToolAllAssemblies = new List <string>(); CrossDomainTraceHelper.StartListening(context.Domain); // tool assembly MetaPackTrace.Verbose("Loading main tool assembly:[{0}]", toolAssembly); context.LoadAssembly(LoadMethod.LoadFile, toolAssembly); var deploymentOptions = new AppDomainDeploymentOptions { PackageFilePath = tmpPackageFilePath, PackagingServiceClassFullName = packagingServiceClassFullName, DeploymentServiceClassFullName = deploymentServiceFullName }; foreach (var opt in SolutionOptions) { deploymentOptions.AdditionalOptions.Add(new DeploymentOption { Name = opt.Name, Value = opt.Value }); } var result = RemoteFunc.Invoke(context.Domain, deploymentOptions, (ops) => { var ress = new AppDomainDeploymentOptions(); MetaPackTrace.Verbose("Extracting additional tools from solutuion package..."); MetaPackTrace.Verbose("Current AppDomain.Id:[{0}]", AppDomain.CurrentDomain.Id); MetaPackTrace.Verbose("Package path:[{0}]", ops.PackageFilePath); MetaPackTrace.Verbose("Packaging service impl:[{0}]", ops.PackagingServiceClassFullName); MetaPackTrace.Verbose("Deployment service impl:[{0}]", ops.DeploymentServiceClassFullName); var allClasses = AppDomain.CurrentDomain .GetAssemblies() .SelectMany(a => a.GetTypes()); var packagingClassType = allClasses.FirstOrDefault(c => c.FullName.ToUpper() == ops.PackagingServiceClassFullName.ToUpper()); var deploymentClassType = allClasses.FirstOrDefault(c => c.FullName.ToUpper() == ops.DeploymentServiceClassFullName.ToUpper()); if (packagingClassType == null) { throw new MetaPackException(string.Format("Cannot find type by full name:[{0}]", ops.PackagingServiceClassFullName)); } if (deploymentClassType == null) { throw new MetaPackException(string.Format("Cannot find type by full name:[{0}]", ops.DeploymentServiceClassFullName)); } MetaPackTrace.Verbose("Creating packaging service implementation..."); var packagingService = Activator.CreateInstance(packagingClassType) as SolutionPackageServiceBase; if (packagingService == null) { throw new MetaPackException("Cannot create instance of packaging service"); } MetaPackTrace.Verbose("Creating deployment service implementation..."); var deploymentService = Activator.CreateInstance(deploymentClassType) as SolutionPackageDeploymentServiceBase; if (deploymentService == null) { throw new MetaPackException("Cannot create instance of deployment service"); } MetaPackTrace.Verbose(string.Format("Reading package:[{0}]", ops.PackageFilePath)); using (var packageStream = System.IO.File.OpenRead(ops.PackageFilePath)) { MetaPackTrace.Verbose(string.Format("Unpacking package...")); var solutionPackage = packagingService.Unpack(packageStream); if (solutionPackage != null) { MetaPackTrace.Verbose(string.Format("Succesfully unpacked package.")); } // deployment options var solutionDeploymentOptions = new SolutionPackageProvisionOptions { SolutionPackage = solutionPackage, }; // fill out deployment options foreach (var option in ops.AdditionalOptions) { solutionDeploymentOptions.SetOptionValue(option.Name, option.Value); } // check for additional tools MetaPackTrace.Verbose(string.Format("Checking additional tools for unpacked package...")); if (deploymentService is SolutionPackageDeploymentService) { MetaPackTrace.Verbose(string.Format("Calling SolutionPackageDeploymentService.GetAdditionalToolPackages()...")); var toolableDeploymentService = deploymentService as SolutionPackageDeploymentService; var additonalTool2s = toolableDeploymentService.GetAdditionalToolPackages(solutionDeploymentOptions); if (additonalTool2s.Count() > 0) { foreach (var tmp in additonalTool2s) { ress.ToolAdditionalPackages.Add(new SolutionToolPackage { Id = tmp.Id, Version = tmp.Version, AssemblyNameHint = tmp.AssemblyNameHint }); } } else { MetaPackTrace.Verbose(string.Format("No additional tools were found")); } } else { MetaPackTrace.Verbose(string.Format("No additional tools are found. Current deployment service isn't of type 'SolutionPackageDeploymentService'")); } MetaPackTrace.Verbose(string.Format("Deploying package...")); } return(ress); }); // checking detected additional tools var detecedAdditionalTools = result.ToolAdditionalPackages; if (detecedAdditionalTools.Count > 0) { MetaPackTrace.Info(string.Format("Solution package requires [{0}] additional tools", detecedAdditionalTools.Count)); foreach (var additionalTool in detecedAdditionalTools) { MetaPackTrace.Info(string.Format(" Installing additional tool [{0}] version [{1}]", additionalTool.Id, additionalTool.Version)); toolResolver.InstallTool(additionalTool.Id, additionalTool.Version); IPackage addToolPackage = null; if (!string.IsNullOrEmpty(additionalTool.Version)) { addToolPackage = toolRepo.FindPackage(additionalTool.Id, new SemanticVersion(additionalTool.Version)); } else { addToolPackage = toolRepo.FindPackage(additionalTool.Id); } var additionalToolAssemblies = toolResolver.ResolveAssemblyPaths(toolRepo, addToolPackage, "net45", false); if (!string.IsNullOrEmpty(additionalTool.AssemblyNameHint)) { detectedAdditionalToolAssemblies.AddRange(additionalToolAssemblies .Where(p => p.ToUpper().Contains(additionalTool.AssemblyNameHint.ToUpper()))); } else { detectedAdditionalToolAssemblies.AddRange(additionalToolAssemblies); } detectedAdditionalToolAllAssemblies.AddRange( toolResolver.ResolveAssemblyPaths(toolRepo, addToolPackage, "net45", true) ); } } if (detectedAdditionalToolAssemblies.Count > 0) { MetaPackTrace.Info("Detected [{0}] assemblies to be loaded", detectedAdditionalToolAssemblies.Count); // tool additional tool assemblies foreach (var tt in detectedAdditionalToolAssemblies) { MetaPackTrace.Info(" Loading tool assembly [{0}]", toolAssembly); context.LoadAssembly(LoadMethod.LoadFile, tt); } } var paths = new List <string>(); // add probing path for ALL tool assemblies foreach (var assemblyDir in detectedAdditionalToolAllAssemblies .Select(p => Path.GetDirectoryName(p)) .Distinct() .OrderBy(d => d)) { MetaPackTrace.Verbose(" Adding additional tool probing path [{0}]", assemblyDir); paths.Add(assemblyDir); context.AssemblyImporter.AddProbePath(assemblyDir); } // add probing path for ALL tool assemblies foreach (var assemblyDir in toolAssemblies .Select(p => Path.GetDirectoryName(p)) .Distinct() .OrderBy(d => d)) { MetaPackTrace.Verbose(" Adding tool probing path [{0}]", assemblyDir); paths.Add(assemblyDir); context.AssemblyImporter.AddProbePath(assemblyDir); } deploymentOptions.AssemblyProbingPaths = paths; var result2 = RemoteFunc.Invoke(context.Domain, deploymentOptions, (ops) => { AppDomain.CurrentDomain.AssemblyResolve += (sss, eee) => { MetaPackTrace.Verbose(string.Format("AppDomain assembly:[{0}]", eee.RequestingAssembly)); MetaPackTrace.Verbose(string.Format("Assembly requested:[{0}]", eee.Name)); if (eee.Name.ToLower().Contains(".resources,")) { MetaPackTrace.Verbose("Resources assembly detected. Returnin NULL"); return(null); } MetaPackTrace.Verbose("Trying to load from local probing paths..."); var assemblyName = eee.Name.Split(',')[0] + ".dll"; foreach (var dir in ops.AssemblyProbingPaths) { var tmpAssemblyPath = Path.Combine(dir, assemblyName); if (System.IO.File.Exists(tmpAssemblyPath)) { MetaPackTrace.Verbose("Loaded from [{0}]", tmpAssemblyPath); return(Assembly.LoadFile(tmpAssemblyPath)); } } MetaPackTrace.Verbose("Coudn't find assembly in local probing path. Trying to load from GAC."); //// GAC call? //if (eee.RequestingAssembly == null && !string.IsNullOrEmpty(eee.Name)) //{ // var asm = Assembly.Load(eee.Name); // if (asm != null) // return asm; // MetaPackTrace.Verbose("Coudn't find assembly in GAC"); //} //MetaPackTrace.Verbose("Cannot resolve requested assembly. Throwing exception."); throw new Exception(string.Format("Cannot load requested assembly [{0}]. Requested by [{1}]", eee.Name, eee.RequestingAssembly)); }; MetaPackTrace.Verbose("Extracting additional tools from solutuion package..."); MetaPackTrace.Verbose("Current AppDomain.Id:[{0}]", AppDomain.CurrentDomain.Id); MetaPackTrace.Verbose("Package path:[{0}]", ops.PackageFilePath); MetaPackTrace.Verbose("Packaging service impl:[{0}]", ops.PackagingServiceClassFullName); MetaPackTrace.Verbose("Deployment service impl:[{0}]", ops.DeploymentServiceClassFullName); var allClasses = AppDomain.CurrentDomain .GetAssemblies() .SelectMany(a => a.GetTypes()); var packagingClassType = allClasses.FirstOrDefault(c => c.FullName.ToUpper() == ops.PackagingServiceClassFullName.ToUpper()); var deploymentClassType = allClasses.FirstOrDefault(c => c.FullName.ToUpper() == ops.DeploymentServiceClassFullName.ToUpper()); if (packagingClassType == null) { throw new MetaPackException(string.Format("Cannot find type by full name:[{0}]", ops.PackagingServiceClassFullName)); } if (deploymentClassType == null) { throw new MetaPackException(string.Format("Cannot find type by full name:[{0}]", ops.DeploymentServiceClassFullName)); } MetaPackTrace.Verbose("Creating packaging service implementation..."); var packagingService = Activator.CreateInstance(packagingClassType) as SolutionPackageServiceBase; if (packagingService == null) { throw new MetaPackException("Cannot create instance of packaging service"); } MetaPackTrace.Verbose("Creating deployment service implementation..."); var deploymentService = Activator.CreateInstance(deploymentClassType) as SolutionPackageDeploymentServiceBase; if (deploymentService == null) { throw new MetaPackException("Cannot create instance of deployment service"); } // unpack package // TODO MetaPackTrace.Verbose(string.Format("Reading package:[{0}]", ops.PackageFilePath)); using (var packageStream = System.IO.File.OpenRead(ops.PackageFilePath)) { MetaPackTrace.Verbose(string.Format("Unpacking package...")); var solutionPackage = packagingService.Unpack(packageStream); if (solutionPackage != null) { MetaPackTrace.Verbose(string.Format("Succesfully unpacked package.")); } // deployment options var solutionDeploymentOptions = new SolutionPackageProvisionOptions { SolutionPackage = solutionPackage, }; // fill out deployment options foreach (var option in ops.AdditionalOptions) { solutionDeploymentOptions.SetOptionValue(option.Name, option.Value); } MetaPackTrace.Info(string.Format("Deploying package...")); deploymentService.Deploy(solutionDeploymentOptions); MetaPackTrace.Info(string.Format("Package deployment cimpleted")); } return(ops); }); } MetaPackTrace.Info("NuGet package installation completed"); }
protected virtual void Info(string msg) { MetaPackTrace.Info(msg); }
protected virtual void Error(string msg) { MetaPackTrace.Error(msg); }
protected virtual void Verbose(string msg) { MetaPackTrace.Verbose(msg); }
public void onProgressDelegate(string m, int s, int t) { MetaPackTrace.Info(string.Format("[SharePointPnP] - {0}/{1} - {2}", new object[] { s, t, m })); }
protected virtual Type ResolveModelHostType(IEnumerable <Type> allClasses, string rootDefinitionClassName, string spApi) { Type modelHostType = null; MetaPackTrace.Verbose(string.Format( "Revolving model host for API:[{0}] and root definition:[{1}]", spApi, rootDefinitionClassName)); if (Compare(spApi, DefaultOptions.SharePoint.Api.SSOM.Value, true)) { MetaPackTrace.Verbose("Searching for SSOM impl..."); if (rootDefinitionClassName == "FarmDefinition") { modelHostType = allClasses.FirstOrDefault(t => t.FullName == "SPMeta2.SSOM.ModelHosts.FarmModelHost"); } else if (rootDefinitionClassName == "WebApplicationDefinition") { modelHostType = allClasses.FirstOrDefault(t => t.FullName == "SPMeta2.SSOM.ModelHosts.WebApplicationModelHost"); } else if (rootDefinitionClassName == "SiteDefinition") { modelHostType = allClasses.FirstOrDefault(t => t.FullName == "SPMeta2.SSOM.ModelHosts.SiteModelHost"); } else if (rootDefinitionClassName == "WebDefinition") { modelHostType = allClasses.FirstOrDefault(t => t.FullName == "SPMeta2.SSOM.ModelHosts.WebModelHost"); } else { throw new MetaPackException( string.Format("Unsupported model with root definition type:[{0}]", rootDefinitionClassName)); } } else if (Compare(spApi, DefaultOptions.SharePoint.Api.CSOM.Value, true)) { MetaPackTrace.Verbose("Searching for CSOM impl..."); if (rootDefinitionClassName == "SiteDefinition") { modelHostType = allClasses.FirstOrDefault(t => t.FullName == "SPMeta2.CSOM.ModelHosts.SiteModelHost"); } else if (rootDefinitionClassName == "WebDefinition") { modelHostType = allClasses.FirstOrDefault(t => t.FullName == "SPMeta2.CSOM.ModelHosts.WebModelHost"); } else { throw new MetaPackException( string.Format("Unsupported model with root definition type:[{0}]", rootDefinitionClassName)); } } if (modelHostType == null) { throw new MetaPackException(string.Format( "Cannot find model host for API:[{0}] and root definition:[{1}]", spApi, rootDefinitionClassName)); } return(modelHostType); }
public void OnModelNodeProcessed(object o, object s) { MetaPackTrace.Info(string.Format("[SPMeta2] - Processed: {0}", GetOnModelNodeEventTraceString(s))); }
private void ProcessCSOMDeployment(SolutionPackageProvisionOptions options, string provisionServiceClassName, IEnumerable <Assembly> allAssemblies, IEnumerable <Type> allClasses, object provisionService, string spVersion, object model, Type modelHostType) { MetaPackTrace.Verbose(string.Format("Detected CSOM provision.")); var m2CSOMAssembly = ReflectionUtils.FindAssemblyByFullName(allAssemblies, "SPMeta2.CSOM, Version=1.0.0.0, Culture=neutral, PublicKeyToken=d71faae3bf28531a"); if (m2CSOMAssembly == null) { throw new MetaPackException(string.Format("Cannot find assembly:[SPMeta2.CSOM]")); } var userName = options.GetOptionValue(DefaultOptions.User.Name.Id); var userPassword = options.GetOptionValue(DefaultOptions.User.Password.Id); var siteUrl = options.GetOptionValue(DefaultOptions.Site.Url.Id); var clientContexClass = ReflectionUtils.FindTypeByName(allClasses, "ClientContext"); if (clientContexClass == null) { throw new MetaPackException(string.Format("Cannot find class by name:[{0}]", "ClientContext")); } MetaPackTrace.Verbose(string.Format("Creating ClientContext for web site:[{0}]", siteUrl)); var clientContextInstance = Activator.CreateInstance(clientContexClass, new object[] { siteUrl }); if (clientContextInstance == null) { throw new MetaPackException(string.Format("Cannot create client context")); } if (Compare(spVersion, DefaultOptions.SharePoint.Version.O365.Value, true)) { // O365 creds MetaPackTrace.Verbose(string.Format("O365 API detected")); if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(userPassword)) { MetaPackTrace.Verbose(string.Format("[{0}] and [{1}] aren't null.", DefaultOptions.User.Name.Id, DefaultOptions.User.Password.Id )); MetaPackTrace.Verbose(string.Format("Creating SharePointOnlineCredentials for web site:[{0}]", siteUrl)); var spCredentialsClass = ReflectionUtils.FindTypeByName(allClasses, "SharePointOnlineCredentials"); if (spCredentialsClass == null) { throw new MetaPackException(string.Format("Cannot find class by name:[{0}]", "SharePointOnlineCredentials")); } var securePassword = new SecureString(); foreach (char c in userPassword) { securePassword.AppendChar(c); } var spCredentialsInstance = Activator.CreateInstance(spCredentialsClass, new object[] { userName, securePassword }); MetaPackTrace.Verbose(string.Format("Setting up credentials...")); ReflectionUtils.SetPropertyValue(clientContextInstance, "Credentials", spCredentialsInstance); } else { throw new MetaPackException(string.Format("O365 provision requires [{0}] and [{1}] to be set.", DefaultOptions.User.Name.Id, DefaultOptions.User.Password.Id )); } } else { MetaPackTrace.Verbose(string.Format("On-premises CSOM API is detected")); // local network creds if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(userPassword)) { MetaPackTrace.Verbose(string.Format("[{0}] and [{1}] aren't null.", DefaultOptions.User.Name.Id, DefaultOptions.User.Password.Id )); MetaPackTrace.Verbose(string.Format("Creating NetworkCredential for web site:[{0}]", siteUrl)); var spCredentialsInstance = new NetworkCredential(userName, userPassword); MetaPackTrace.Verbose(string.Format("Setting up credentials...")); ReflectionUtils.SetPropertyValue(clientContextInstance, "Credentials", spCredentialsInstance); } else { MetaPackTrace.Verbose(string.Format("No username/userpassword were provided for site:[{0}]", siteUrl)); } } var modelHostFromClientContextMethod = modelHostType.GetMethod("FromClientContext"); if (modelHostFromClientContextMethod == null) { throw new MetaPackException("Cannot find FromClientContext method on model host"); } MetaPackTrace.Verbose(string.Format("Creating model host instance of type:[{0}]", modelHostType)); var modelHostInstance = modelHostFromClientContextMethod.Invoke(null, new object[] { clientContextInstance }); MetaPackTrace.Verbose(string.Format("Created model host instance of type:[{0}]", modelHostInstance)); var provisionMethod = ReflectionUtils.GetMethod(provisionService, "DeployModel"); if (provisionMethod == null) { throw new MetaPackException( string.Format("Cannot find 'DeployModel' on the provision service of type:[{0}]", provisionServiceClassName)); } else { MetaPackTrace.Verbose(string.Format("Found .DeployModel method.")); } // so much lazy to clean up that mess var provisionServiceType = provisionService.GetType(); var onModelNodeProcessingEvent = provisionServiceType.GetField("OnModelNodeProcessing", BindingFlags.Public | BindingFlags.Instance); var onModelNodeProcessingHandler = GetType().GetMethod("OnModelNodeProcessing"); var onModelNodeProcessingDelegate = Delegate.CreateDelegate(onModelNodeProcessingEvent.FieldType, this, onModelNodeProcessingHandler); onModelNodeProcessingEvent.SetValue(provisionService, onModelNodeProcessingDelegate); var onModelNodeProcessedEvent = provisionServiceType.GetField("OnModelNodeProcessed", BindingFlags.Public | BindingFlags.Instance); var onModelNodeProcessedHandler = GetType().GetMethod("OnModelNodeProcessed"); var onModelNodeProcessedDelegate = Delegate.CreateDelegate(onModelNodeProcessingEvent.FieldType, this, onModelNodeProcessedHandler); onModelNodeProcessedEvent.SetValue(provisionService, onModelNodeProcessedDelegate); MetaPackTrace.Verbose(string.Format("Starting provision...")); provisionMethod.Invoke(provisionService, new[] { modelHostInstance, model }); MetaPackTrace.Verbose(string.Format("Provision completed.")); }
private void ProcessSSOMDeployment(SolutionPackageProvisionOptions options, string provisionServiceClassName, IEnumerable <Assembly> allAssemblies, IEnumerable <Type> allClasses, object provisionService, string spVersion, object model, Type modelHostType) { MetaPackTrace.Verbose(string.Format("Detected SSOM provision.")); var m2SSOMAssembly = ReflectionUtils.FindAssemblyByFullName(allAssemblies, "SPMeta2.SSOM, Version=1.0.0.0, Culture=neutral, PublicKeyToken=d71faae3bf28531a"); if (m2SSOMAssembly == null) { throw new MetaPackException(string.Format("Cannot find assembly:[SPMeta2.SSOM]")); } var siteUrl = options.GetOptionValue(DefaultOptions.Site.Url.Id); MethodInfo modelHostFromXXXMethod = null; if (modelHostType.Name == "SiteModelHost") { modelHostFromXXXMethod = modelHostType.GetMethod("FromSite"); } else if (modelHostType.Name == "WebModelHost") { modelHostFromXXXMethod = modelHostType.GetMethod("FromWeb"); } else if (modelHostType.Name == "WebApplicationModelHost") { modelHostFromXXXMethod = modelHostType.GetMethod("FromWebApplication"); } else if (modelHostType.Name == "FarmModelHost") { modelHostFromXXXMethod = modelHostType.GetMethod("FromFarm"); } else { throw new MetaPackException(string.Format("Unknown model host type:[{0}]", modelHostType.Name)); } if (modelHostFromXXXMethod == null) { throw new MetaPackException(string.Format("Cannot find FromXXX for model host of type:[{0}]", modelHostType)); } object spHost = new object(); // load up sharepoint assembly if not there yet var spAssembly = allAssemblies.FirstOrDefault(a => a.FullName.Contains("Microsoft.SharePoint,")); if (spAssembly == null) { // fall back t SP2010 but 15-16 must work as well var spAssemblyName = "Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c"; spAssembly = Assembly.Load(spAssemblyName); if (spAssembly == null) { throw new MetaPackException( string.Format("Cannot load assembly:[{0}]", spAssemblyName)); } } if (modelHostType.Name == "FarmModelHost") { var spHostTypeName = "Microsoft.SharePoint.Administration.SPFarm"; var spHostType = spAssembly.GetType(spHostTypeName); if (spHostType == null) { throw new MetaPackException( string.Format("Cannot find type:[{0}]", spHostTypeName)); } MetaPackTrace.Verbose(string.Format("SPFarm: creating new SharePoint host of type:[{0}]", spHostTypeName)); spHost = ReflectionUtils.GetStaticPropertyValue(spHostType, "Local"); if (spHost == null) { throw new MetaPackException( string.Format("Cannot create spHost of type type:[{0}]", spHostType)); } } else if (modelHostType.Name == "WebApplicationModelHost") { var spHostTypeName = "Microsoft.SharePoint.Administration.SPWebApplication"; var spHostType = spAssembly.GetType(spHostTypeName); if (spHostType == null) { throw new MetaPackException( string.Format("Cannot find type:[{0}]", spHostTypeName)); } MetaPackTrace.Verbose(string.Format("SPWebApplication: creating new SharePoint host of type:[{0}] for Url:[{1}]", spHostTypeName, siteUrl)); spHost = ReflectionUtils.InvokeStaticMethod(spHostType, "Lookup", new object[] { siteUrl }); if (spHost == null) { throw new MetaPackException( string.Format("Cannot create spHost of type type:[{0}]", spHostType)); } } else if (modelHostType.Name == "SiteModelHost" || modelHostType.Name == "WebModelHost") { var spHostTypeName = "Microsoft.SharePoint.SPSite"; var spHostType = spAssembly.GetType(spHostTypeName); if (spHostType == null) { throw new MetaPackException( string.Format("Cannot find type:[{0}]", spHostTypeName)); } MetaPackTrace.Verbose(string.Format("SPSite: new SharePoint host of type:[{0}] for Url:[{1}]", spHostTypeName, siteUrl)); spHost = Activator.CreateInstance(spHostType, siteUrl); MetaPackTrace.Verbose("Created SPSite instance for Url:[{0}]", siteUrl); if (modelHostType.Name == "WebModelHost") { MetaPackTrace.Verbose("Opening SPWeb for instance Url:[{0}]", siteUrl); spHost = ReflectionUtils.InvokeMethod(spHost, "OpenWeb"); } if (spHost == null) { throw new MetaPackException( string.Format("Cannot create spHost of type type:[{0}]", spHostType)); } } MetaPackTrace.Verbose(string.Format("Creating model host instance of type:[{0}]", modelHostType)); object clientContextInstance = spHost; var modelHostInstance = modelHostFromXXXMethod.Invoke(null, new object[] { clientContextInstance }); MetaPackTrace.Verbose(string.Format("Created model host instance of type:[{0}]", modelHostInstance)); var provisionMethod = ReflectionUtils.GetMethod(provisionService, "DeployModel"); if (provisionMethod == null) { throw new MetaPackException( string.Format("Cannot find 'DeployModel' on the provision service of type:[{0}]", provisionServiceClassName)); } else { MetaPackTrace.Verbose(string.Format("Found .DeployModel method.")); } // so much lazy to clean up that mess var provisionServiceType = provisionService.GetType(); var onModelNodeProcessingEvent = provisionServiceType.GetField("OnModelNodeProcessing", BindingFlags.Public | BindingFlags.Instance); var onModelNodeProcessingHandler = GetType().GetMethod("OnModelNodeProcessing"); var onModelNodeProcessingDelegate = Delegate.CreateDelegate(onModelNodeProcessingEvent.FieldType, this, onModelNodeProcessingHandler); onModelNodeProcessingEvent.SetValue(provisionService, onModelNodeProcessingDelegate); var onModelNodeProcessedEvent = provisionServiceType.GetField("OnModelNodeProcessed", BindingFlags.Public | BindingFlags.Instance); var onModelNodeProcessedHandler = GetType().GetMethod("OnModelNodeProcessed"); var onModelNodeProcessedDelegate = Delegate.CreateDelegate(onModelNodeProcessingEvent.FieldType, this, onModelNodeProcessedHandler); onModelNodeProcessedEvent.SetValue(provisionService, onModelNodeProcessedDelegate); MetaPackTrace.Verbose(string.Format("Starting provision...")); provisionMethod.Invoke(provisionService, new[] { modelHostInstance, model }); MetaPackTrace.Verbose(string.Format("Provision completed.")); if (spHost is IDisposable) { MetaPackTrace.Verbose(string.Format("Disposing spHost object of type:[{0}]", spHost.GetType())); ((IDisposable)spHost).Dispose(); spHost = null; } else { MetaPackTrace.Verbose(string.Format("No need to dispose spHost object of type:[{0}]", spHost.GetType())); } }
public override void Deploy(SolutionPackageProvisionOptions options) { MetaPackTrace.Verbose("Resolving provision class..."); var provisionServiceClassName = GetProvisionServiceClassName(options); MetaPackTrace.Verbose(string.Format("Resolved as:[{0}]", provisionServiceClassName)); MetaPackTrace.Verbose("Resolving provision class type..."); var allAssemblies = ReflectionUtils.GetAllAssembliesFromCurrentAppDomain(); var allClasses = ReflectionUtils.GetAllTypesFromCurrentAppDomain(); MetaPackTrace.Verbose("All assemblies"); foreach (var assembly in allAssemblies) { MetaPackTrace.Verbose(" " + assembly.FullName); } var provisionServiceClass = ReflectionUtils.FindTypeByFullName(allClasses, provisionServiceClassName); if (provisionServiceClass == null) { throw new MetaPackException(string.Format("Cannot find provision service imp by name:[{0}]", provisionServiceClassName)); } else { MetaPackTrace.Verbose(string.Format("Found as type as:[{0}]", provisionServiceClass)); } MetaPackTrace.Verbose(string.Format("Creating provision service instance...")); var provisionService = Activator.CreateInstance(provisionServiceClass); // reoad, cause SPMeta2.dll will be loaded only once provisionServiceClass is created allAssemblies = ReflectionUtils.GetAllAssembliesFromCurrentAppDomain(); var m2CoreAssembly = ReflectionUtils.FindAssemblyByFullName(allAssemblies, "SPMeta2, Version=1.0.0.0, Culture=neutral, PublicKeyToken=d71faae3bf28531a"); var m2coreClasses = m2CoreAssembly.GetTypes().OrderBy(s => s.Name); var spMeta2ModelClass = m2coreClasses.FirstOrDefault(c => c.Name == "SPMeta2Model"); var fromXMLMethod = spMeta2ModelClass.GetMethods().FirstOrDefault(m => m.Name == "FromXML" && m.ReturnType.Name == "ModelNode"); var solutionPackage = options.SolutionPackage as SolutionPackageBase; if (solutionPackage == null) { throw new MetaPackException("SolutionPackage is not of type SPMeta2SolutionPackage"); } if (provisionService == null) { throw new MetaPackException(string.Format("provisionService is null. Tried to create from:[{0}]", provisionServiceClassName)); } var spVersion = options.GetOptionValue(DefaultOptions.SharePoint.Version.Id); var spEdition = options.GetOptionValue(DefaultOptions.SharePoint.Edition.Id); var spApi = options.GetOptionValue(DefaultOptions.SharePoint.Api.Id); MetaPackTrace.Verbose(string.Format("spVersion:[{0}]", spVersion)); MetaPackTrace.Verbose(string.Format("spEdition:[{0}]", spEdition)); MetaPackTrace.Verbose(string.Format("spApi:[{0}]", spApi)); var models = solutionPackage.GetModels(); MetaPackTrace.Verbose(string.Format("Starting provision for [{0}] models", models.Count())); foreach (var modelContainer in models) { if (modelContainer.Model == null) { throw new MetaPackException("model is null or empty"); } var modelContent = UTF8Encoding.UTF8.GetString(modelContainer.Model); var model = fromXMLMethod.Invoke(null, new object[] { modelContent }); var rootDefinitionValue = model.GetType().GetProperty("Value") .GetValue(model); var rootDefinitionClassName = rootDefinitionValue.GetType().Name; MetaPackTrace.Verbose(string.Format("Provisioning model [{0}]", rootDefinitionValue.GetType().Name)); MetaPackTrace.Verbose(string.Format("Resolving model host type...")); var modelHostType = ResolveModelHostType(allClasses, rootDefinitionClassName, spApi); MetaPackTrace.Verbose(string.Format("Resolved as [{0}]", modelHostType)); if (modelHostType == null) { throw new MetaPackException(string.Format("Cannot resolve model host type")); } if (Compare(spApi, DefaultOptions.SharePoint.Api.CSOM.Value, true)) { ProcessCSOMDeployment(options, provisionServiceClassName, allAssemblies, allClasses, provisionService, spVersion, model, modelHostType); } else { ProcessSSOMDeployment(options, provisionServiceClassName, allAssemblies, allClasses, provisionService, spVersion, model, modelHostType); } } }
private void InitProvisionEvents() { MetaPackTrace.Verbose("Initialized provision events"); PackageInstalling += OnPackageInstalling; }
/// <summary> /// Resolves solution tool package. /// /// If .SolutionToolPackage is null, looking for NuGet package tags, and then into solution /// </summary> /// <returns></returns> protected virtual SolutionToolPackage ResolveSolutionToolPackage(IPackage package) { MetaPackTrace.Verbose("Resolving solution tool packages..."); SolutionToolPackage result = null; if (SolutionToolPackage == null) { MetaPackTrace.Verbose(".SolutionToolPackage is null. Switching to tags and solution itself"); // resolve from the tags var tags = string.IsNullOrEmpty(package.Tags) ? package.Tags.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries) : Enumerable.Empty <string>(); var packageId = ExtractTagValueByPrefix(tags, "metapack-toolid-"); var packageVersion = ExtractTagValueByPrefix(tags, "metapack-toolid-"); if (!string.IsNullOrEmpty(packageId)) { MetaPackTrace.Verbose(String.Format("Found tool. ToolId:[{0}] ToolVersion:[{1}]", packageId, packageVersion)); result = new SolutionToolPackage { Id = packageId, Version = packageVersion }; } else { MetaPackTrace.Verbose("Solution package tags don't have tool package defined. Switching to solution options."); var defaultSolutionPackagingService = new DefaultNuGetSolutionPackageService(); var solutionPackageFile = defaultSolutionPackagingService.FindSolutionPackageFile(package); var serializationService = new DefaultXMLSerializationService(); serializationService.RegisterKnownType(typeof(SolutionPackageBase)); MetaPackTrace.Verbose("Unpacking solution package..."); using (var streamReader = new StreamReader(solutionPackageFile.GetStream())) { var solutionFileContent = streamReader.ReadToEnd(); var xDoc = XDocument.Parse(solutionFileContent); var rootElementName = xDoc.Root.Name.LocalName; var defNamespace = xDoc.Root.Attribute("xmlns").Value; var genericXmlDoc = xDoc.ToString() .Replace( string.Format("<{0}", rootElementName), string.Format("<{0}", typeof(SolutionPackageBase).Name)) .Replace( string.Format("</{0}>", rootElementName), string.Format("</{0}>", typeof(SolutionPackageBase).Name)) .Replace(defNamespace, "http://schemas.datacontract.org/2004/07/MetaPack.Core.Packaging"); var typedPackage = serializationService.Deserialize( typeof(SolutionPackageBase), genericXmlDoc) as SolutionPackageBase; var packageIdFromPackage = ExtractAdditionalOption(typedPackage.AdditionalOptions, DefaultOptions.SolutionToolPackage.PackageId.Id); var packageVersionFromPackage = ExtractAdditionalOption(typedPackage.AdditionalOptions, DefaultOptions.SolutionToolPackage.PackageVersion.Id); if (!string.IsNullOrEmpty(packageIdFromPackage)) { MetaPackTrace.Verbose(string.Format("Found tool. ToolId:[{0}] ToolVersion:[{1}]", packageIdFromPackage, packageVersionFromPackage)); result = new SolutionToolPackage { Id = packageIdFromPackage, Version = packageVersionFromPackage }; } else { MetaPackTrace.Verbose("Cannot find any solution tool package options in SolutionPackage.AdditionalOptions"); } } } if (result == null) { throw new MetaPackException("Can't resolve solution tool package from .SolutionToolPackage, tags and solution package itself"); } } else { MetaPackTrace.Verbose("SolutionToolPackage is preefined by external input."); result = SolutionToolPackage; } return(result); }
public override void Deploy(SolutionPackageProvisionOptions options) { var spVersion = options.GetOptionValue(DefaultOptions.SharePoint.Version.Id); var spEdition = options.GetOptionValue(DefaultOptions.SharePoint.Edition.Id); var spApi = options.GetOptionValue(DefaultOptions.SharePoint.Api.Id); MetaPackTrace.Verbose(string.Format("spVersion:[{0}]", spVersion)); MetaPackTrace.Verbose(string.Format("spEdition:[{0}]", spEdition)); MetaPackTrace.Verbose(string.Format("spApi:[{0}]", spApi)); if (!Compare(spApi, DefaultOptions.SharePoint.Api.CSOM.Value, true)) { throw new NotSupportedException(string.Format("SharePoint API [{0}] is not supported yet", spApi)); } var allAssemblies = ReflectionUtils.GetAllAssembliesFromCurrentAppDomain(); var allClasses = ReflectionUtils.GetAllTypesFromCurrentAppDomain(); var pnpAssembly = allAssemblies.FirstOrDefault(a => a.FullName.Contains("OfficeDevPnP.Core,")); var spClientAssembly = allAssemblies.FirstOrDefault(a => a.FullName.Contains("Microsoft.SharePoint.Client,")); var spClientRuntimeAssembly = allAssemblies.FirstOrDefault(a => a.FullName.Contains("Microsoft.SharePoint.Client.Runtime,")); var allSharePointClasses = new List <Type>(); allSharePointClasses.AddRange(spClientAssembly.GetTypes()); allSharePointClasses.AddRange(spClientRuntimeAssembly.GetTypes()); MetaPackTrace.Verbose("Resolving provision class..."); var solutionPackage = options.SolutionPackage as SolutionPackageBase; var solutionModels = solutionPackage.GetModels(); MetaPackTrace.Verbose(string.Format("Found [{0}] models", solutionModels.Count())); var siteToTemplateConversionType = "OfficeDevPnP.Core.Framework.Provisioning.ObjectHandlers.SiteToTemplateConversion"; var fileSystemConnectorType = "OfficeDevPnP.Core.Framework.Provisioning.Connectors.FileSystemConnector"; var openXMLTemplateProviderType = "OfficeDevPnP.Core.Framework.Provisioning.Providers.Xml.XMLOpenXMLTemplateProvider"; var provisioningTemplateApplyingInformationType = "OfficeDevPnP.Core.Framework.Provisioning.ObjectHandlers.ProvisioningTemplateApplyingInformation"; var openXmlConnectorType = "OfficeDevPnP.Core.Framework.Provisioning.Connectors.OpenXMLConnector"; var currentModelIndex = 0; var allModelsCount = solutionModels.Count(); foreach (var modelContainer in solutionModels) { currentModelIndex++; MetaPackTrace.Verbose(string.Format(" - deploying model [{0}/{1}]", currentModelIndex, allModelsCount)); // "SharePointPnP.FolderZip" // "SharePointPnP.OpenXml" var modelType = "SharePointPnP.OpenXml"; var modelTypeOption = modelContainer.AdditionalOptions .FirstOrDefault(o => o.Name.ToUpper() == DefaultOptions.Model.Type.Id); if (modelTypeOption != null) { modelType = modelTypeOption.Value; } MetaPackTrace.Verbose(string.Format(" - model type: [{0}]", modelType)); MetaPackTrace.Verbose(string.Format("Detected CSOM provision.")); var userName = options.GetOptionValue(DefaultOptions.User.Name.Id); var userPassword = options.GetOptionValue(DefaultOptions.User.Password.Id); var siteUrl = options.GetOptionValue(DefaultOptions.Site.Url.Id); MetaPackTrace.Verbose(string.Format("Creating ClientContext for web site:[{0}]", siteUrl)); var clientContexClass = ReflectionUtils.FindTypeByName(allSharePointClasses, "ClientContext"); if (clientContexClass == null) { throw new MetaPackException(string.Format("Cannot find class by name:[{0}]", "ClientContext")); } MetaPackTrace.Verbose(string.Format("Creating ClientContext for web site:[{0}]", siteUrl)); var clientContextInstance = Activator.CreateInstance(clientContexClass, new object[] { siteUrl }); if (clientContextInstance == null) { throw new MetaPackException(string.Format("Cannot create client context")); } var web = ReflectionUtils.GetPropertyValue(clientContextInstance, "Web"); if (Compare(spVersion, DefaultOptions.SharePoint.Version.O365.Value, true)) { MetaPackTrace.Verbose(string.Format("O365 API detected")); if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(userPassword)) { MetaPackTrace.Verbose(string.Format("[{0}] and [{1}] aren't null.", DefaultOptions.User.Name.Id, DefaultOptions.User.Password.Id )); MetaPackTrace.Verbose(string.Format("Creating Credentials for web site:[{0}]", siteUrl)); var spCredentialsClass = ReflectionUtils.FindTypeByName(allSharePointClasses, "SharePointOnlineCredentials"); if (spCredentialsClass == null) { throw new MetaPackException(string.Format("Cannot find class by name:[{0}]", "SharePointOnlineCredentials")); } var securePassword = new SecureString(); foreach (char c in userPassword) { securePassword.AppendChar(c); } var spCredentialsInstance = Activator.CreateInstance(spCredentialsClass, new object[] { userName, securePassword }); MetaPackTrace.Verbose(string.Format("Setting up credentials...")); ReflectionUtils.SetPropertyValue(clientContextInstance, "Credentials", spCredentialsInstance); } else { throw new MetaPackException(string.Format("O365 provision requires [{0}] and [{1}] to be set.", DefaultOptions.User.Name.Id, DefaultOptions.User.Password.Id )); } } else { MetaPackTrace.Verbose(string.Format("On-premises CSOM API is detected")); // local network creds if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(userPassword)) { MetaPackTrace.Verbose(string.Format("[{0}] and [{1}] aren't null.", DefaultOptions.User.Name.Id, DefaultOptions.User.Password.Id )); MetaPackTrace.Verbose(string.Format("Creating NetworkCredential for web site:[{0}]", siteUrl)); var spCredentialsInstance = new NetworkCredential(userName, userPassword); MetaPackTrace.Verbose(string.Format("Setting up credentials...")); ReflectionUtils.SetPropertyValue(clientContextInstance, "Credentials", spCredentialsInstance); } else { MetaPackTrace.Verbose(string.Format("No username/userpassword were provided for site:[{0}]", siteUrl)); } } if (modelType.ToUpper() == "SharePointPnP.OpenXml".ToUpper()) { var tmpFileFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N")); Directory.CreateDirectory(tmpFileFolder); var tmpFilePath = Path.Combine(tmpFileFolder, Guid.NewGuid().ToString("N") + ".pnp"); System.IO.File.WriteAllBytes(tmpFilePath, modelContainer.Model); var pnpPackage = tmpFilePath; var filConnectorPath = Path.GetDirectoryName(pnpPackage); var fileSystemConnectorInstance = pnpAssembly.CreateInstance(fileSystemConnectorType, true, BindingFlags.CreateInstance, null, new object[] { filConnectorPath, "" }, CultureInfo.CurrentCulture, null); var fileSystemConnector = fileSystemConnectorInstance; var fileName = Path.GetFileName(pnpPackage); MetaPackTrace.Verbose(string.Format("Deploying package:[{0}]", fileName)); var openXMLConnectorInstance = pnpAssembly.CreateInstance(openXmlConnectorType, true, BindingFlags.CreateInstance, null, new object[] { fileName, fileSystemConnector, null, null }, CultureInfo.CurrentCulture, null); var providerInstance = pnpAssembly.CreateInstance(openXMLTemplateProviderType, true, BindingFlags.CreateInstance, null, new object[] { openXMLConnectorInstance }, CultureInfo.CurrentCulture, null); MetaPackTrace.Verbose(string.Format("Fetching templates...")); var provider = providerInstance; var getTemplatesMethod = provider.GetType().GetMethods() .FirstOrDefault(m => m.Name == "GetTemplates" && m.GetParameters().Length == 0); var templates = getTemplatesMethod.Invoke(provider, null) as IEnumerable; var templatesCount = 0; foreach (var template in templates) { templatesCount++; } MetaPackTrace.Verbose(string.Format("Found [{0}] templates", templatesCount)); var providerConnector = ReflectionUtils.GetPropertyValue(provider, "Connector"); var currentTemplateIndex = 0; foreach (var template in templates) { currentTemplateIndex++; ReflectionUtils.SetPropertyValue(template, "Connector", providerConnector); MetaPackTrace.Verbose(string.Format("Deploying template [{0}/{1}]", currentTemplateIndex, templatesCount)); var templateId = ReflectionUtils.GetPropertyValue(template, "Id"); MetaPackTrace.Verbose(string.Format(" -ID:[{0}]", templateId)); var provisionOptions = pnpAssembly.CreateInstance(provisioningTemplateApplyingInformationType); var delType = provisionOptions.GetType(); var templateDisplayName = ReflectionUtils.GetPropertyValue(template, "DisplayName"); MetaPackTrace.Verbose(string.Format(" -DisplayName:[{0}]", templateDisplayName)); var siteToTemplateConversionInstance = pnpAssembly.CreateInstance(siteToTemplateConversionType); var onMessageDelegate = delType.GetProperty("MessagesDelegate", BindingFlags.Public | BindingFlags.Instance); var onMessageHandler = GetType().GetMethod("onMessagesDelegate"); var onMessageDelegateImpl = Delegate.CreateDelegate(onMessageDelegate.PropertyType, this, onMessageHandler); onMessageDelegate.SetValue(provisionOptions, onMessageDelegateImpl); var onProgressDelegate = delType.GetProperty("ProgressDelegate", BindingFlags.Public | BindingFlags.Instance); var onProgressHandler = GetType().GetMethod("onProgressDelegate"); var onProgressDelegateImpl = Delegate.CreateDelegate(onProgressDelegate.PropertyType, this, onProgressHandler); onProgressDelegate.SetValue(provisionOptions, onProgressDelegateImpl); var applyRemoteTemplateMethod = siteToTemplateConversionInstance.GetType() .GetMethod("ApplyRemoteTemplate", BindingFlags.Instance | BindingFlags.NonPublic); applyRemoteTemplateMethod.Invoke(siteToTemplateConversionInstance, new object[] { web, template, provisionOptions }); } } else { var errMesssage = string.Format("Deloyment models of type [{0}] is not supported yet", modelType); MetaPackTrace.Info(errMesssage); throw new MetaPackException(errMesssage); } } }
protected virtual void InternalExecute() { if (PackageSources.Count == 0) { throw new ArgumentException("Source"); } if (string.IsNullOrEmpty(Id)) { throw new ArgumentException("Id"); } if (string.IsNullOrEmpty(Url)) { throw new ArgumentException("Url"); } if (IsSharePointOnline) { if (string.IsNullOrEmpty(UserName)) { throw new ArgumentException("UserName"); } if (string.IsNullOrEmpty(UserPassword)) { throw new ArgumentException("UserPassword"); } } var spService = new SharePointService(); spService.WithSharePointContext(Url, UserName, UserPassword, IsSharePointOnline, context => { // connect to remote repo var repo = new AggregateRepository(PackageRepositoryFactory.Default, PackageSources, true); IPackage package = null; if (!string.IsNullOrEmpty(Version)) { MetaPackTrace.Info("Fetching package [{0}] with version [{1}]", Id, Version); package = repo.FindPackage(Id, new SemanticVersion(Version)); } else { MetaPackTrace.Info("Fetching the latest package [{0}]", Id); package = repo.FindPackage(Id); } if (package == null) { MetaPackTrace.Info("Cannot find package [{0}]. Throwing exception.", Id); throw new ArgumentException("package"); } else { } MetaPackTrace.Info("Found package [{0}] version [{1}].", package.Id, package.Version); MetaPackTrace.Info("Installing package to SharePoint web site..."); // create manager with repo and current web site var packageManager = CreatePackageManager(repo, context); // install package if (Force) { MetaPackTrace.Info("Force flag is true. Looking for existing package..."); var currentPackage = packageManager.LocalRepository.FindPackage( package.Id, package.Version, this.PreRelease, true); if (currentPackage != null) { MetaPackTrace.Info(string.Format( "Package [{0}] version [{1}] already exists. Uninstalling...", currentPackage.Id, currentPackage.Version)); packageManager.UninstallPackage(package); // we need a fresh start due to cached nuet packages // TODO - rewrite SharePointCSOMFileSystem to support deletions better packageManager = CreatePackageManager(repo, context); } else { MetaPackTrace.Info(string.Format( "Package [{0}] version [{1}] does not exist. It will be deployed.", package.Id, package.Version)); } } else { var currentPackage = packageManager.LocalRepository.FindPackage( package.Id, package.Version, this.PreRelease, true); if (currentPackage != null) { MetaPackTrace.Info(string.Format( "Package [{0}] version [{1}] already exists. Use --force flag to redeploy it.", currentPackage.Id, currentPackage.Version)); return; } } packageManager.InstallPackage(package, false, PreRelease); MetaPackTrace.Info("Completed installation. All good!"); }); }
public void onMessagesDelegate(string s, tt t) { MetaPackTrace.Info(string.Format("[SharePointPnP] - {0}", s)); }