protected virtual string GetProvisionServiceClassName(SolutionPackageProvisionOptions options)
{
var provisionServiceClassName = string.Empty;
var spVersion = options.GetOptionValue(DefaultOptions.SharePoint.Version.Id);
var spEdition = options.GetOptionValue(DefaultOptions.SharePoint.Edition.Id);
var spApi = options.GetOptionValue(DefaultOptions.SharePoint.Api.Id);
if (Compare(spEdition, DefaultOptions.SharePoint.Edition.Foundation.Value, true))
{
if (Compare(spApi, DefaultOptions.SharePoint.Api.CSOM.Value, true))
{
provisionServiceClassName = "SPMeta2.CSOM.Services.CSOMProvisionService";
}
else if (Compare(spApi, DefaultOptions.SharePoint.Api.SSOM.Value, true))
{
provisionServiceClassName = "SPMeta2.SSOM.Services.SSOMProvisionService";
}
else
{
throw new MetaPackException(String.Format("Unsuported SharePoint Api:[{0}]", spApi));
}
}
else if (Compare(spEdition, DefaultOptions.SharePoint.Edition.Standard.Value, true))
{
if (Compare(spApi, DefaultOptions.SharePoint.Api.CSOM.Value, true))
{
provisionServiceClassName = "SPMeta2.CSOM.Standard.Services.StandardCSOMProvisionService";
}
else if (Compare(spApi, DefaultOptions.SharePoint.Api.SSOM.Value, true))
{
provisionServiceClassName = "SPMeta2.SSOM.Standard.Services.StandardSSOMProvisionService";
}
else
{
throw new MetaPackException(String.Format("Unsuported SharePoint Api:[{0}]", spApi));
}
}
else
{
throw new MetaPackException(String.Format("Unsuported SharePoint Edition:[{0}]", spEdition));
}
return(provisionServiceClassName);
}
public abstract void Deploy(SolutionPackageProvisionOptions options);
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");
}
public override IEnumerable <SolutionToolPackage> GetAdditionalToolPackages(SolutionPackageProvisionOptions options)
{
var result = new List <SolutionToolPackage>();
var mainToolPackageId = string.Empty;
var spVersion = options.GetOptionValue(DefaultOptions.SharePoint.Version.Id);
var spEdition = options.GetOptionValue(DefaultOptions.SharePoint.Edition.Id);
var spApi = options.GetOptionValue(DefaultOptions.SharePoint.Api.Id);
if (!Compare(spApi, DefaultOptions.SharePoint.Api.CSOM.Value, true))
{
throw new MetaPackException(String.Format("Unsupported SharePoint Api:[{0}]", spApi));
}
if (Compare(spVersion, DefaultOptions.SharePoint.Version.O365.Value))
{
mainToolPackageId = "SharePointPnPCoreOnline";
result.Add(new SolutionToolPackage
{
Id = "Microsoft.SharePointOnline.CSOM",
AssemblyNameHint = "Microsoft.SharePoint.Client.dll"
});
result.Add(new SolutionToolPackage
{
Id = "Microsoft.SharePointOnline.CSOM",
AssemblyNameHint = "Microsoft.SharePoint.Client.Runtime.dll"
});
}
else if (Compare(spVersion, DefaultOptions.SharePoint.Version.SP2013.Value))
{
mainToolPackageId = "SharePointPnPCore2013";
// adding main toolpackage
result.Add(new SolutionToolPackage
{
Id = "Microsoft.SharePoint2013.CSOM",
Version = "15.0.4711.1000",
AssemblyNameHint = "Microsoft.SharePoint.Client.dll"
});
result.Add(new SolutionToolPackage
{
Id = "Microsoft.SharePoint2013.CSOM",
Version = "15.0.4711.1000",
AssemblyNameHint = "Microsoft.SharePoint.Client.Runtime.dll"
});
}
else if (Compare(spVersion, DefaultOptions.SharePoint.Version.SP2016.Value))
{
throw new NotImplementedException();
}
else
{
throw new MetaPackException(String.Format("Unsupported SharePoint Version:[{0}]", spVersion));
}
result.Add(new SolutionToolPackage
{
Id = mainToolPackageId
});
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);
}
}
}
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 IEnumerable <SolutionToolPackage> GetAdditionalToolPackages(SolutionPackageProvisionOptions options)
{
var result = new List <SolutionToolPackage>();
var mainToolPackageId = "SPMeta2";
var spVersion = options.GetOptionValue(DefaultOptions.SharePoint.Version.Id);
var spEdition = options.GetOptionValue(DefaultOptions.SharePoint.Edition.Id);
var spApi = options.GetOptionValue(DefaultOptions.SharePoint.Api.Id);
// ensure m2 assemblies
if (Compare(spApi, DefaultOptions.SharePoint.Api.CSOM.Value, true))
{
mainToolPackageId += ".CSOM";
}
else if (Compare(spApi, DefaultOptions.SharePoint.Api.SSOM.Value, true))
{
mainToolPackageId += ".SSOM";
}
else
{
throw new MetaPackException(String.Format("Unsuported SharePoint Api:[{0}]", spApi));
}
if (Compare(spEdition, DefaultOptions.SharePoint.Edition.Foundation.Value, true))
{
mainToolPackageId += ".Foundation";
}
else if (Compare(spEdition, DefaultOptions.SharePoint.Edition.Standard.Value, true))
{
mainToolPackageId += ".Standard";
if (Compare(spApi, DefaultOptions.SharePoint.Api.CSOM.Value, true))
{
if (Compare(spVersion, DefaultOptions.SharePoint.Version.O365.Value, true))
{
result.Add(new SolutionToolPackage
{
Id = "SPMeta2.CSOM.Foundation-v16",
AssemblyNameHint = "SPMeta2.CSOM.dll"
});
}
else
{
result.Add(new SolutionToolPackage
{
Id = "SPMeta2.CSOM.Foundation",
AssemblyNameHint = "SPMeta2.CSOM.dll"
});
}
}
if (Compare(spApi, DefaultOptions.SharePoint.Api.SSOM.Value, true))
{
result.Add(new SolutionToolPackage
{
Id = "SPMeta2.SSOM.Foundation",
AssemblyNameHint = "SPMeta2.SSOM.dll"
});
}
}
else
{
throw new MetaPackException(String.Format("Unsuported SharePoint Edition:[{0}]", spEdition));
}
if (Compare(spVersion, DefaultOptions.SharePoint.Version.O365.Value, true))
{
mainToolPackageId += "-v16";
// adding main toolpackage
result.Add(new SolutionToolPackage
{
Id = "Microsoft.SharePointOnline.CSOM",
AssemblyNameHint = "Microsoft.SharePoint.Client.dll"
});
result.Add(new SolutionToolPackage
{
Id = "Microsoft.SharePointOnline.CSOM",
AssemblyNameHint = "Microsoft.SharePoint.Client.Runtime.dll"
});
}
else if (Compare(spVersion, DefaultOptions.SharePoint.Version.SP2013.Value, true))
{
if (Compare(spApi, DefaultOptions.SharePoint.Api.CSOM.Value, true))
{
// download stuff from NuGet
// loading from GAC is not suported yet
// ideally we'd like to get SP1 version
// 15.0.4569.1000* Service Pack 1 SharePoint Foundation 2013 KB2817439 Download Bugs, Notes, and Regressions
// 15.0.4711.1000 April 2015 CU SharePoint Foundation 2013 KB2965261 Download Bugs, Notes, and Regressions
// adding main toolpackage
result.Add(new SolutionToolPackage
{
Id = "Microsoft.SharePoint2013.CSOM",
Version = "15.0.4711.1000",
AssemblyNameHint = "Microsoft.SharePoint.Client.dll"
});
result.Add(new SolutionToolPackage
{
Id = "Microsoft.SharePoint2013.CSOM",
Version = "15.0.4711.1000",
AssemblyNameHint = "Microsoft.SharePoint.Client.Runtime.dll"
});
}
}
else if (Compare(spVersion, DefaultOptions.SharePoint.Version.SP2016.Value, true))
{
// same as 2013 yet
if (Compare(spApi, DefaultOptions.SharePoint.Api.CSOM.Value, true))
{
result.Add(new SolutionToolPackage
{
Id = "Microsoft.SharePoint2013.CSOM",
Version = "15.0.4711.1000",
AssemblyNameHint = "Microsoft.SharePoint.Client.dll"
});
result.Add(new SolutionToolPackage
{
Id = "Microsoft.SharePoint2013.CSOM",
Version = "15.0.4711.1000",
AssemblyNameHint = "Microsoft.SharePoint.Client.Runtime.dll"
});
}
}
else
{
throw new MetaPackException(String.Format("Unsuported SharePoint Version:[{0}]", spVersion));
}
// adding main toolpackage
result.Add(new SolutionToolPackage
{
Id = mainToolPackageId
});
return(result);
}
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);
}
}
}
public virtual IEnumerable <SolutionToolPackage> GetAdditionalToolPackages(SolutionPackageProvisionOptions options)
{
return(Enumerable.Empty <SolutionToolPackage>());
}
