public ModuleLoaderContext(IServiceProvider serviceProvider,
string projectDirectory)
{
ProjectDirectory = projectDirectory;
RootDirectory = Microsoft.Framework.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
// A new project resolver is required. you cannot reuse the one from the
// parent service provider as that will be for the parent context.
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(new FrameworkReferenceResolver());
// Need to pass through package directory incase you download a package from the gallary, this needs to know about it
var nuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository(
NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory)));
var gacDependencyResolver = new GacDependencyResolver();
var projectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileFormat.LockFileName);
if (File.Exists(projectLockJsonPath))
{
var lockFileFormat = new LockFileFormat();
var lockFile = lockFileFormat.Read(projectLockJsonPath);
nuGetDependencyProvider.ApplyLockFile(lockFile);
}
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
projectDepencyProvider,
nuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ModuleProjectLibraryExportProvider(
ProjectResolver, serviceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
nuGetDependencyProvider
});
}
public string CreateSqlBackup()
{
var server = new Server(_databaseServer);
var dependencyWalker = new DependencyWalker(server);
var database = server.Databases[_databaseName];
var tables = (database.Tables.Cast <Table>().Where(table => table.IsSystemObject == false || table.Name == "sysdiagrams").Select(table => table.Urn)).ToArray();
var dependencyTree = dependencyWalker.DiscoverDependencies(tables, true);
var dependencyCollection = dependencyWalker.WalkDependencies(dependencyTree);
var strings = new List <string>();
var schemaScripter = new Scripter(server)
{
Options =
new ScriptingOptions
{
ClusteredIndexes = true,
Default = true,
DriAll = true,
ExtendedProperties = true,
IncludeHeaders = false,
Indexes = true,
}
};
var schemaScripts = dependencyCollection.SelectMany(x => schemaScripter.Script(new[] { x.Urn }).Cast <string>()).ToList();
strings.AddRange(schemaScripts);
strings.Add("GO");
var dataScripter = new Scripter(server)
{
Options = new ScriptingOptions {
ScriptData = true, ScriptSchema = false
}
};
var dataScripts = dataScripter.EnumScriptWithList(dependencyCollection);
strings.AddRange(dataScripts);
return(String.Join("\r\n", strings));
}
private IEnumerable <DependencyCollectionNode> GetDependencies(SqlSmoObject smoObject, Location location)
{
Logger.WriteLine("Gathering dependencies for {0}", smoObject.Urn);
try
{
var dependencyWalker = new DependencyWalker(location == Location.Source ? _sourceServer : _targetServer);
DependencyTree parents = dependencyWalker.DiscoverDependencies(new[] { smoObject },
DependencyType.Parents);
DependencyCollection dependencies = dependencyWalker.WalkDependencies(parents);
return(dependencies);
}
catch
{
Logger.WriteLine("Failed to get dependencies for {0}", smoObject.Urn);
throw;
}
}
private static int CountTableDependancies(Scripter scripter, SqlSmoObject[] objectArray)
{
int retVal = 0;
DependencyWalker dependencyWalker = new DependencyWalker(scripter.Server);
DependencyTree dependencyTree = dependencyWalker.DiscoverDependencies(objectArray, true);
DependencyCollection dependencyCollection = dependencyWalker.WalkDependencies(dependencyTree);
foreach (DependencyCollectionNode oneDep in dependencyCollection)
{
if (oneDep.Urn.Type.Equals("Table"))
{
retVal++;
}
}
return(retVal);
}
public void HigherDisputedDependencyWins()
{
var testProvider = new TestDependencyProvider()
.Package("a", "1.0", that => that.Needs("b", "1.0").Needs("c", "1.0"))
.Package("b", "1.0", that => that.Needs("x", "1.0"))
.Package("c", "1.0", that => that.Needs("x", "2.0"))
.Package("x", "1.0")
.Package("x", "2.0");
var walker = new DependencyWalker(new[] { testProvider });
walker.Walk("a", new SemanticVersion("1.0"), VersionUtility.ParseFrameworkName("net45"));
AssertDependencies(testProvider.Dependencies, that => that
.Needs("a", "1.0")
.Needs("b", "1.0")
.Needs("c", "1.0")
.Needs("x", "2.0"));
}
private SqlSmoObject[] Sort(Database sourceDatabase, SqlSmoObject[] smoObjects)
{
if (smoObjects.Count() < 2)
{
return(smoObjects);
}
DependencyTree dt = null;
DependencyWalker dw = new DependencyWalker(sourceDatabase.Parent);
try
{
dt = dw.DiscoverDependencies(smoObjects, true);
}
catch (Exception ex)
{
AsyncNotificationEventArgs eventArgs = new AsyncNotificationEventArgs(NotificationEventFunctionCode.ExecuteSqlOnAzure, 100, "", DateTime.Now.ToString(CultureInfo.CurrentCulture) + Environment.NewLine + ex.Message, Color.Red);
_updateStatus(eventArgs);
return(smoObjects);
}
SqlSmoObject[] sorted = new SqlSmoObject[smoObjects.Count()];
int index = 0;
foreach (DependencyCollectionNode d in dw.WalkDependencies(dt))
{
if (d.Urn.Type.Equals("UnresolvedEntity"))
{
continue;
}
foreach (SqlSmoObject sso in smoObjects)
{
if (sso.Urn.ToString().Equals(d.Urn, StringComparison.CurrentCultureIgnoreCase))
{
sorted[index++] = sso;
break;
}
}
}
return(sorted);
}
public void NearestDependencyVersionWins()
{
var testProvider = new TestDependencyProvider()
.Package("a", "1.0", that => that.Needs("b", "1.0").Needs("c", "1.0").Needs("x", "1.0"))
.Package("b", "1.0", that => that.Needs("x", "2.0"))
.Package("c", "1.0", that => that.Needs("x", "2.0"))
.Package("x", "1.0")
.Package("x", "2.0");
var walker = new DependencyWalker(new[] { testProvider });
walker.Walk("a", new SemanticVersion("1.0"), VersionUtility.ParseFrameworkName("net45"));
testProvider.Dependencies.ShouldBe(Dependencies(that => that
.Needs("a", "1.0")
.Needs("b", "1.0")
.Needs("c", "1.0")
.Needs("x", "1.0")
));
}
private SqlSmoObject[] Sort(Database sourceDatabase, SqlSmoObject[] smoObjects)
{
if (smoObjects.Count() < 2)
{
return(smoObjects);
}
DependencyTree dt = null;
var dw = new DependencyWalker(sourceDatabase.Parent);
try
{
dt = dw.DiscoverDependencies(smoObjects, true);
}
catch //(Exception ex)
{
//ErrorHelper.ShowException(this, ex);
return(smoObjects);
}
var sorted = new SqlSmoObject[smoObjects.Count()];
var index = 0;
foreach (var d in dw.WalkDependencies(dt))
{
if (d.Urn.Type.Equals("UnresolvedEntity"))
{
continue;
}
foreach (var sso in smoObjects)
{
if (sso.Urn.ToString().Equals(d.Urn, StringComparison.CurrentCultureIgnoreCase))
{
sorted[index++] = sso;
break;
}
}
}
return(sorted);
}
public ModuleLoaderContext(IServiceProvider serviceProvider,
string projectDirectory,
ICache cache)
{
_serviceProvider = serviceProvider;
_cache = cache;
ProjectDirectory = projectDirectory;
RootDirectory = Microsoft.Framework.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
// A new project resolver is required. you cannot reuse the one from the
// parent service provider as that will be for the parent context.
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(new FrameworkReferenceResolver());
// Need to pass through package directory incase you download a package from the gallary, this needs to know about it
var NuGetDependencyProvider = new NuGetDependencyResolver(
NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory), RootDirectory);
var gacDependencyResolver = new GacDependencyResolver();
var ProjectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDepencyProvider,
NuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ModuleProjectLibraryExportProvider(
ProjectResolver, _serviceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
NuGetDependencyProvider
});
}
private static List <View> SortViews(Database db, List <SqlSmoObject> sso)
{
var dw = new DependencyWalker(db.Parent);
var dt = new DependencyTree(dw.DiscoverDependencies(sso.ToArray(), true));
var views = new List <View>();
foreach (var d in dw.WalkDependencies(dt))
{
if (d.Urn.Type != "View")
{
continue;
}
var o = db.Views[d.Urn.GetNameForType(d.Urn.Type)];
if (o != null)
{
views.Add(db.Views[d.Urn.GetNameForType(d.Urn.Type)]);
}
}
return(views);
}
private static List<View> SortViews(Database db, List<SqlSmoObject> sso)
{
var dw = new DependencyWalker(db.Parent);
var dt = new DependencyTree(dw.DiscoverDependencies(sso.ToArray(), true));
var views = new List<View>();
foreach (var d in dw.WalkDependencies(dt))
{
if (d.Urn.Type != "View")
continue;
var o = db.Views[d.Urn.GetNameForType(d.Urn.Type)];
if (o != null)
views.Add(db.Views[d.Urn.GetNameForType(d.Urn.Type)]);
}
return views;
}
private static void GenereateData(Database db, Scripter scripter, StringBuilder sbScript)
{
var tbls = new Table[db.Tables.Count];
db.Tables.CopyTo(tbls, 0);
var tree = scripter.DiscoverDependencies(tbls, true);
var depwalker = new DependencyWalker();
var depcoll = depwalker.WalkDependencies(tree);
var sb = new StringBuilder();
//progressBar1.Maximum = sviews.Count;
foreach (DependencyCollectionNode dep in depcoll)
{
var o = db.Tables[dep.Urn.GetAttribute("Name")];
if (o != null && !o.IsSystemObject)
sb.AppendFormat("EXEC sp_generate_inserts @table_name='{0}', @owner='dbo'{1}", dep.Urn.GetAttribute("Name"), Environment.NewLine);
}
DataSet dset = db.ExecuteWithResults(sb.ToString());
foreach (DataTable dt in dset.Tables)
{
foreach (DataRow dr in dt.Rows)
{
sbScript.AppendLine(dr[0].ToString());
}
}
}
/// <summary>
/// Activates the LayoutManager. This performs dependency analysis and starts listening for the form's Resize event (upon which the layout will be updated).
/// The relative positions of bound controls is determined by the offset at activation.
/// For example, if a control's right side is bound to the form's right side and its right side is 12 pixels to the
/// left of the form's right side, that 12 pixel difference will be maintained by the LayoutManager.
/// </summary>
public void Activate()
{
if (!Activated)
{
Form.Resize += OnFormResize;
Activated = true;
// Prepare a dependency graph for the controls
var controls = new HashSet <Control>(); // Nodes
var controlBindings = new Dictionary <Control, HashSet <Binding> >(); // Node values
var dependencies = new Dictionary <Control, HashSet <Control> >(); // Edges (direction 1)
var dependers = new Dictionary <Control, HashSet <Control> >(); // Edges (direction 2)
foreach (Binding binding in Bindings)
{
// Set the initial values for use when evaluating the bindings
binding.InitialValue = binding.Value;
binding.InitialDependentValue = binding.DependentValue;
// Populate the graph nodes
controls.Add(binding.Control);
controlBindings.AddMulti(binding.Control, binding);
// Ensure each control has a key in dependencies/dependers
dependencies.AddMulti(binding.Control, Enumerable.Empty <Control>());
dependers.AddMulti(binding.Control, Enumerable.Empty <Control>());
// Populate the graph edges by examining the binding's value expression
var walker = new DependencyWalker();
walker.Visit(binding.ValueFunc);
foreach (Control control in walker.Dependencies)
{
if (control == binding.Control)
{
throw new InvalidOperationException("The layout bindings for control " + control.Name + " are self-dependent.");
}
controls.Add(control); // Populate the graph nodes
dependers.AddMulti(control, binding.Control);
dependencies.AddMulti(binding.Control, control);
dependencies.AddMulti(control, Enumerable.Empty <Control>()); // Ensure each control has a key in dependencies/dependers
}
}
// Topological sorting (see http://en.wikipedia.org/wiki/Topological_sorting)
activatedControlBindings.Clear();
var controlsWithoutDependencies = new HashSet <Control>(controls.Where(x => dependencies[x].Count == 0));
while (controlsWithoutDependencies.Count > 0)
{
var control = controlsWithoutDependencies.First();
controlsWithoutDependencies.Remove(control);
if (controlBindings.ContainsKey(control))
{
activatedControlBindings.Add(new KeyValuePair <Control, HashSet <Binding> >(control, controlBindings[control]));
}
while (dependers[control].Count > 0)
{
var depender = dependers[control].First();
dependers[control].Remove(depender);
dependencies[depender].Remove(control);
if (dependencies[depender].Count == 0)
{
controlsWithoutDependencies.Add(depender);
}
}
}
var controlsInDependencyCycles = dependencies.Where(x => x.Value.Count > 0).ToList();
if (controlsInDependencyCycles.Count > 0)
{
throw new InvalidOperationException("The layout bindings have one or more cycles including these controls: " + string.Join(", ", controlsInDependencyCycles.Select(x => x.Key.Name)));
}
}
}
private static void ProcessLevel(Level lvl, Database db, Server srv)
{
foreach (Level level in lvl.Levels)
{
Table table = db.Tables[level.Name];
if (table != null)
{
Index oldpk = table.Indexes.Cast <Index>().FirstOrDefault(index => index.IndexKeyType == IndexKeyType.DriPrimaryKey);
if (oldpk != null && oldpk.IndexedColumns.Count < 2)
{
DependencyWalker dw = new DependencyWalker(srv);
DependencyTree dependencies = dw.DiscoverDependencies(new SqlSmoObject[] { table }, DependencyType.Children);
DependencyTreeNode current = dependencies.FirstChild.FirstChild;
List <ForeignKey> oldfks = new List <ForeignKey>();
List <ForeignKey> newfks = new List <ForeignKey>();
_spsw.WriteLine();
_spsw.Write(table.Name + ":");
bool checkself = false;
while (current != null)
{
if (srv.GetSmoObject(current.Urn) is StoredProcedure sp)
{
_spsw.Write(sp.Name + "; ");
}
if (srv.GetSmoObject(current.Urn) is Table dependency)
{
foreach (ForeignKey oldfk in dependency.ForeignKeys)
{
if (oldfk.ReferencedTable == table.Name)
{
_dropfksw.WriteLine(string.Format(DROP_CONSTRAINT, dependency.Name, oldfk.Name));
ForeignKey newfk = new ForeignKey(dependency, oldfk.Name);
string columns1 = string.Empty;
string columns2 = string.Empty;
bool _first = true;
foreach (ForeignKeyColumn fkc in oldfk.Columns)
{
columns1 += (_first ? "" : ", ") + fkc.Name;
columns2 += (_first ? "" : ", ") + fkc.ReferencedColumn;
_first = false;
newfk.Columns.Add(new ForeignKeyColumn(newfk, fkc.Name, fkc.ReferencedColumn));
}
if (level.Parent != null)
{
foreach (ForeignKey fk in dependency.ForeignKeys)
{
if (fk.ReferencedTable == level.Parent.Name)
{
foreach (ForeignKeyColumn fkc in fk.Columns)
{
columns1 += (_first ? "" : ", ") + fkc.Name;
columns2 += (_first ? "" : ", ") + fkc.ReferencedColumn;
_first = false;
newfk.Columns.Add(new ForeignKeyColumn(newfk, fkc.Name, fkc.ReferencedColumn));
}
}
}
if (level.Parent.Parent != null)
{
foreach (ForeignKey fk in dependency.ForeignKeys)
{
if (fk.ReferencedTable == level.Parent.Parent.Name)
{
foreach (ForeignKeyColumn fkc in fk.Columns)
{
columns1 += (_first ? "" : ", ") + fkc.Name;
columns2 += (_first ? "" : ", ") + fkc.ReferencedColumn;
_first = false;
newfk.Columns.Add(new ForeignKeyColumn(newfk, fkc.Name, fkc.ReferencedColumn));
}
}
}
}
}
newfk.ReferencedTable = oldfk.ReferencedTable;
newfk.ReferencedTableSchema = oldfk.ReferencedTableSchema;
_addfksw.WriteLine(string.Format(ADD_FK_CONSTRAINT, dependency.Name, oldfk.Name, columns1, oldfk.ReferencedTable, columns2));
oldfks.Add(oldfk);
newfks.Add(newfk);
}
}
}
current = current.NextSibling;
if (current == null && !checkself)
{
current = dependencies.FirstChild;
checkself = true;
}
}
_droppksw.WriteLine(string.Format(DROP_CONSTRAINT, table.Name, oldpk.Name));
Index newpk = new Index(table, oldpk.Name);
string columns = string.Empty;
bool first = true;
foreach (IndexedColumn ic in oldpk.IndexedColumns)
{
columns += (first ? "" : ", ") + ic.Name;
first = false;
newpk.IndexedColumns.Add(new IndexedColumn(newpk, ic.Name));
}
if (level.Parent != null)
{
foreach (ForeignKey fk in table.ForeignKeys)
{
if (fk.ReferencedTable == level.Parent.Name)
{
foreach (ForeignKeyColumn fkc in fk.Columns)
{
columns += (first ? "" : ", ") + fkc.Name;
first = false;
newpk.IndexedColumns.Add(new IndexedColumn(newpk, fkc.Name));
}
}
}
if (level.Parent.Parent != null)
{
foreach (ForeignKey fk in table.ForeignKeys)
{
if (fk.ReferencedTable == level.Parent.Parent.Name)
{
foreach (ForeignKeyColumn fkc in fk.Columns)
{
columns += (first ? "" : ", ") + fkc.Name;
first = false;
newpk.IndexedColumns.Add(new IndexedColumn(newpk, fkc.Name));
}
}
}
}
}
newpk.IsClustered = true;
newpk.IsUnique = true;
newpk.IndexKeyType = IndexKeyType.DriPrimaryKey;
_addpksw.WriteLine(string.Format(ADD_PK_CONSTRAINT, table.Name, oldpk.Name, columns));
ProcessLevel(level, db, srv);
Console.Write(table.Name + "\r\n");
try
{
foreach (ForeignKey oldfk in oldfks)
{
oldfk.Drop();
table.Alter();
}
oldpk.Drop();
table.Alter();
newpk.Create();
foreach (ForeignKey newfk in newfks)
{
newfk.Create();
}
}
catch (Exception ex)
{
Console.Write(ex.Message + "\r\n");
}
}
}
}
}
public IEnumerable<DependencyCollectionNode> GetDependencies(SqlSmoObject smo)
{
var dependencyWalker = new DependencyWalker(_server);
var depTree = dependencyWalker.DiscoverDependencies(new[] { smo }, true);
return dependencyWalker.WalkDependencies(depTree);
}
/// <summary>
/// Runs the export.
/// </summary>
public void Run()
{
// Create server and database connection
this.server = new Server(this.config.server);
Database db = this.server.Databases[this.config.database];
// Collections for objects with and without dependancies
List <Urn> dependentObjects = new List <Urn>();
List <SqlSmoObject> independentObjectsFirst = new List <SqlSmoObject>();
List <DataTable> dtList = new List <DataTable>();
string[] names = Enum.GetNames(typeof(DatabaseObjectTypes));
DatabaseObjectTypes[] values = (DatabaseObjectTypes[])Enum.GetValues(typeof(DatabaseObjectTypes));
for (int i = 0; i < names.Length; i++)
{
string name = names[i];
if (name != "All" && Array.IndexOf(this.config.excludeTypes.ToUpper().Split(','), name.ToUpper()) == -1)
{
this.logger.Debug("Getting objects: " + name);
dtList.Add(db.EnumObjects(values[i]));
}
}
foreach (DataTable dt in dtList)
{
foreach (DataRow dr in dt.Rows)
{
// Select all objects, or only the named object
if (this.config.objectName == null || dr["Name"].Equals(this.config.objectName))
{
// Ignore excluded schemas
if (Array.IndexOf(Config.aExcludedSchemas, dr["Schema"]) == -1)
{
Urn urn = new Urn(dr["Urn"].ToString());
// Ignore excluded types
if (Array.IndexOf(this.config.excludeTypes.ToUpper().Split(','), urn.Type.ToUpper()) == -1)
{
// Split into dependant / independant types
if (Array.IndexOf(Config.aDependentTypeOrder, dr["DatabaseObjectTypes"].ToString()) != -1)
{
// Add the URN to the dependent object list
dependentObjects.Add(urn);
}
else
{
// Add the sqlSmoObject to the independent object list
SqlSmoObject sqlSmoObject = this.server.GetSmoObject(urn);
if (sqlSmoObject is ServiceBroker)
{
// For ServiceBroker object, add child BrokerServices and not self
foreach (BrokerService brokerService in (sqlSmoObject as ServiceBroker).Services)
{
this.independentObjectsLast.Add(brokerService);
}
}
else
{
// Other objects
independentObjectsFirst.Add(sqlSmoObject);
}
}
}
}
}
}
}
// Export database creation
if (this.config.scriptDatabase)
{
this.ScriptObject(db);
}
// Sort independent objects
SMOObjectComparer smoObjectComparer = new SMOObjectComparer();
independentObjectsFirst.Sort(smoObjectComparer);
this.independentObjectsLast.Sort(smoObjectComparer);
// Export starting independent objects
foreach (SqlSmoObject sqlSmoObject in independentObjectsFirst)
{
this.ScriptObject(sqlSmoObject);
}
// Get dependancy information, sort and export dependent objects
if (dependentObjects.Count > 0)
{
// Sort and export dependent objects types
DependencyWalker dependencyWalker = new DependencyWalker(this.server);
DependencyTree dependencyTree =
dependencyWalker.DiscoverDependencies(dependentObjects.ToArray(), DependencyType.Parents);
this.ScriptDependencyTreeNode(dependencyTree);
}
// Export ending independent objects
foreach (SqlSmoObject sqlSmoObject in this.independentObjectsLast)
{
this.ScriptObject(sqlSmoObject);
}
// Output file order information
if (this.fileBuildOrder.Count > 0)
{
// Get filename
string fileName = this.config.orderFilename;
this.logger.Debug("Creating Order file: " + fileName);
if (this.config.outputDirectory != null)
{
fileName = Path.Combine(this.config.outputDirectory, fileName);
}
// Create output directory if needed
string g = Path.GetDirectoryName(fileName);
if (g.Length != 0)
{
Directory.CreateDirectory(g);
}
StreamWriter sw = new StreamWriter(fileName);
foreach (string s in this.fileBuildOrder)
{
sw.WriteLine(s);
}
sw.Close();
}
}
private void Walk(string projectName, SemanticVersion projectVersion)
{
DependencyWalker.Walk(projectName, projectVersion, FrameworkName);
}
public DependencyInformationLoader(DependencyWalker dependencyWalker)
{
DependencyWalker = dependencyWalker;
}
public bool DoesXHaveTransientDependencyOnY(T x, T y)
{
var traverser = new DependencyWalker(this);
return(traverser.DoesXHaveTransientDependencyOnY(x, y));
}
public ProjectHostContext(IServiceProvider serviceProvider,
string projectDirectory,
string packagesDirectory,
string[] sourcePaths,
string configuration,
FrameworkName targetFramework,
ICache cache,
ICacheContextAccessor cacheContextAccessor,
INamedCacheDependencyProvider namedCacheDependencyProvider,
IAssemblyLoadContextFactory loadContextFactory = null)
{
ProjectDirectory = projectDirectory;
Configuration = configuration;
RootDirectory = Microsoft.Framework.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory, sourcePaths);
FrameworkReferenceResolver = new FrameworkReferenceResolver();
_serviceProvider = new ServiceProvider(serviceProvider);
PackagesDirectory = packagesDirectory ?? NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(FrameworkReferenceResolver);
NuGetDependencyProvider = new NuGetDependencyResolver(PackagesDirectory, RootDirectory);
var gacDependencyResolver = new GacDependencyResolver();
ProjectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDepencyProvider,
NuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ProjectLibraryExportProvider(ProjectResolver, ServiceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
NuGetDependencyProvider
});
LibraryManager = new LibraryManager(targetFramework, configuration, DependencyWalker,
LibraryExportProvider, cache);
AssemblyLoadContextFactory = loadContextFactory ?? new AssemblyLoadContextFactory(ServiceProvider);
var sourceCodeService = new SourceTextService(cache);
var provider = new RoslynProjectReferenceProvider(cache, cacheContextAccessor, namedCacheDependencyProvider, loadContextFactory, _serviceProvider.GetService <IFileWatcher>(), _serviceProvider);
// Default services
_serviceProvider.Add(typeof(IApplicationEnvironment), new ApplicationEnvironment(Project, targetFramework, configuration));
_serviceProvider.Add(typeof(ILibraryExportProvider), LibraryExportProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IProjectResolver), ProjectResolver);
_serviceProvider.Add(typeof(IFileWatcher), NoopWatcher.Instance);
_serviceProvider.Add(typeof(NuGetDependencyResolver), NuGetDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ProjectReferenceDependencyProvider), ProjectDepencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ILibraryManager), LibraryManager);
_serviceProvider.Add(typeof(ICache), cache);
_serviceProvider.Add(typeof(ICacheContextAccessor), cacheContextAccessor);
_serviceProvider.Add(typeof(INamedCacheDependencyProvider), namedCacheDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IAssemblyLoadContextFactory), AssemblyLoadContextFactory);
_serviceProvider.Add(typeof(IProjectReferenceProvider), provider);
_serviceProvider.Add(typeof(ISourceTextService), sourceCodeService);
}
/// <summary>
/// Performs the NuGet package resolution.
/// </summary>
public override bool Execute()
{
var analyzers = new List <ITaskItem>();
var copyLocalItems = new List <ITaskItem>();
var references = new List <ITaskItem>();
var providers = new List <IDependencyProvider>();
if (!String.IsNullOrEmpty(PackageRoot))
{
providers.Add(new NuGetDependencyResolver(PackageRoot));
}
else
{
// Find and add all our package folders
var parentDirectory = new DirectoryInfo(Environment.CurrentDirectory);
while (parentDirectory != null)
{
if (parentDirectory.GetDirectories("packages").Any())
{
providers.Add(new NuGetDependencyResolver(Path.Combine(parentDirectory.FullName, "packages")));
}
parentDirectory = parentDirectory.Parent;
}
providers.Add(new NuGetDependencyResolver(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".dnx", "packages")));
}
providers.Add(new MSBuildDependencyProvider(ProjectFile, NuGetPackageReferences));
var walker = new DependencyWalker(providers);
var root = walker.Walk(ProjectFile, new NuGetVersion(new Version()), NuGetFramework.Parse(TargetFrameworkMonikers.First()));
root.TryResolveConflicts();
var resolvedItems = new Dictionary <string, Library>();
// Pick the relevant versions of the package after conflict
// resolution
root.ForEach(true, (node, state) =>
{
if (node.Disposition != Disposition.Accepted ||
node.Item == null)
{
return(false);
}
if (!resolvedItems.ContainsKey(node.Key.Name))
{
resolvedItems[node.Key.Name] = node.Item.Data;
}
return(true);
});
var patternDefinitions = new PatternDefinitions();
if (UseDotNetNativeToolchain)
{
var directoriesToPrep = new[] { IlcTargetFrameworkPath, IlcTargetFrameworkFacadesPath };
foreach (var directoryToPrep in directoriesToPrep)
{
var directoryInfoToPrep = new DirectoryInfo(directoryToPrep);
directoryInfoToPrep.Create();
foreach (var file in directoryInfoToPrep.GetFiles())
{
file.Delete();
}
}
}
foreach (var library in resolvedItems.Values)
{
if (library.Identity.Type != LibraryTypes.Package)
{
continue;
}
Log.LogMessage(MessageImportance.Low, "Resolved references from {0}:", library.Identity.ToString());
LoadContents(library);
var compileTimeReferences = TryGetTaskItemsFromLibrary(library, patternDefinitions.CompileTimeAssemblies);
var copyLocalReferences = TryGetTaskItemsFromLibrary(library, patternDefinitions.ManagedAssemblies) ?? Enumerable.Empty <ITaskItem>();
var copyLocalNativeReferences = TryGetTaskItemsFromLibrary(library, patternDefinitions.NativeLibraries) ?? Enumerable.Empty <ITaskItem>();
var itemsInAot = TryGetTaskItemsFromLibrary(library, patternDefinitions.AheadOfTimeAssemblies) ?? Enumerable.Empty <ITaskItem>();
if (compileTimeReferences == null)
{
// Then the "copy local" references are actually our compile-time references
compileTimeReferences = copyLocalReferences;
}
if (compileTimeReferences != null)
{
ApplyCompileTimeReferenceMetadata(compileTimeReferences, library);
foreach (var compileTimeReference in compileTimeReferences)
{
Log.LogMessage(MessageImportance.Low, " Build time reference: {0}", compileTimeReference.ItemSpec);
references.Add(compileTimeReference);
}
}
if (UseDotNetNativeToolchain)
{
var frameworkAotItems = itemsInAot.Any() ? itemsInAot : copyLocalReferences;
foreach (var frameworkAotItem in frameworkAotItems)
{
File.Copy(frameworkAotItem.ItemSpec, Path.Combine(IlcTargetFrameworkFacadesPath, Path.GetFileName(frameworkAotItem.ItemSpec)), overwrite: true);
}
foreach (var referenceItem in compileTimeReferences)
{
File.Copy(referenceItem.ItemSpec, Path.Combine(IlcTargetFrameworkPath, Path.GetFileName(referenceItem.ItemSpec)), overwrite: true);
}
}
else
{
foreach (var copyLocalReference in copyLocalReferences.Concat(copyLocalNativeReferences))
{
Log.LogMessage(MessageImportance.Low, " Copy local reference: {0}", copyLocalReference.ItemSpec);
copyLocalItems.Add(copyLocalReference);
}
}
}
ResolvedAnalyzers = analyzers.ToArray();
ResolvedCopyLocalItems = copyLocalItems.ToArray();
ResolvedReferences = references.ToArray();
return(true);
}
/// <summary>
/// Activates the LayoutManager. This performs dependency analysis and starts listening for the form's Resize event (upon which the layout will be updated).
/// The relative positions of bound controls is determined by the offset at activation.
/// For example, if a control's right side is bound to the form's right side and its right side is 12 pixels to the
/// left of the form's right side, that 12 pixel difference will be maintained by the LayoutManager.
/// </summary>
public void Activate()
{
if (!Activated)
{
Form.Resize += OnFormResize;
Activated = true;
// Prepare a dependency graph for the controls
var controls = new HashSet<Control>(); // Nodes
var controlBindings = new Dictionary<Control, HashSet<Binding>>(); // Node values
var dependencies = new Dictionary<Control, HashSet<Control>>(); // Edges (direction 1)
var dependers = new Dictionary<Control, HashSet<Control>>(); // Edges (direction 2)
foreach (Binding binding in Bindings)
{
// Set the initial values for use when evaluating the bindings
binding.InitialValue = binding.Value;
binding.InitialDependentValue = binding.DependentValue;
// Populate the graph nodes
controls.Add(binding.Control);
controlBindings.AddMulti(binding.Control, binding);
// Ensure each control has a key in dependencies/dependers
dependencies.AddMulti(binding.Control, Enumerable.Empty<Control>());
dependers.AddMulti(binding.Control, Enumerable.Empty<Control>());
// Populate the graph edges by examining the binding's value expression
var walker = new DependencyWalker();
walker.Visit(binding.ValueFunc);
foreach (Control control in walker.Dependencies)
{
if (control == binding.Control)
{
throw new InvalidOperationException("The layout bindings for control " + control.Name + " are self-dependent.");
}
controls.Add(control); // Populate the graph nodes
dependers.AddMulti(control, binding.Control);
dependencies.AddMulti(binding.Control, control);
dependencies.AddMulti(control, Enumerable.Empty<Control>()); // Ensure each control has a key in dependencies/dependers
}
}
// Topological sorting (see http://en.wikipedia.org/wiki/Topological_sorting)
activatedControlBindings.Clear();
var controlsWithoutDependencies = new HashSet<Control>(controls.Where(x => dependencies[x].Count == 0));
while (controlsWithoutDependencies.Count > 0)
{
var control = controlsWithoutDependencies.First();
controlsWithoutDependencies.Remove(control);
if (controlBindings.ContainsKey(control))
{
activatedControlBindings.Add(new KeyValuePair<Control, HashSet<Binding>>(control, controlBindings[control]));
}
while (dependers[control].Count > 0)
{
var depender = dependers[control].First();
dependers[control].Remove(depender);
dependencies[depender].Remove(control);
if (dependencies[depender].Count == 0)
{
controlsWithoutDependencies.Add(depender);
}
}
}
var controlsInDependencyCycles = dependencies.Where(x => x.Value.Count > 0).ToList();
if (controlsInDependencyCycles.Count > 0)
{
throw new InvalidOperationException("The layout bindings have one or more cycles including these controls: " + string.Join(", ", controlsInDependencyCycles.Select(x => x.Key.Name)));
}
}
}
public void Walk(string projectName, SemanticVersion projectVersion)
{
DependencyWalker.Walk(projectName, projectVersion, FrameworkName);
PackageAssemblies = NuGetDependencyResolver.PackageAssemblyLookup.Values.ToLookup(a => a.Library.Identity.Name);
}
/// <summary>
/// The dependency graph for the specified project and returns a <see cref="DependencyManager"/>
/// containing the full set of resolved dependencies
/// </summary>
/// <param name="dependencyProviders">The <see cref="IDependencyProvider"/> objects to use to locate dependencies</param>
/// <param name="name">The name of the root dependency to resolve</param>
/// <param name="version">The version of the root dependency to resolve</param>
/// <param name="targetFramework">The target framework of the root dependency to resolve</param>
/// <returns></returns>
public static DependencyManager ResolveDependencies(
IEnumerable <IDependencyProvider> dependencyProviders,
string name,
NuGetVersion version,
NuGetFramework targetFramework)
{
GraphNode <Library> graph;
var librariesByType = new Dictionary <string, ISet <Library> >();
var librariesByName = new Dictionary <string, Library>();
var libraries = new Dictionary <string, Library>();
using (Log.LogTimedMethod())
{
// Walk dependencies
var walker = new DependencyWalker(dependencyProviders);
graph = walker.Walk(name, version, targetFramework);
// Resolve conflicts
if (!graph.TryResolveConflicts())
{
throw new InvalidOperationException("Failed to resolve conflicting dependencies!");
}
// Build the resolved dependency list
graph.ForEach(node =>
{
// Everything should be Accepted or Rejected by now
Debug.Assert(node.Disposition != Disposition.Acceptable);
if (node.Disposition == Disposition.Accepted)
{
var library = node.Item.Data;
// Add the library to the sets
librariesByName[node.Item.Data.Identity.Name] = node.Item.Data;
librariesByType.GetOrAdd(library.Identity.Type,
s => new HashSet <Library>(Library.IdentityComparer))
.Add(library);
}
});
}
// Write the graph
if (Log.IsEnabled(LogLevel.Debug))
{
Log.LogDebug("Dependency Graph:");
if (graph == null || graph.Item == null)
{
Log.LogDebug(" <no dependencies>");
}
else
{
graph.Dump(s => Log.LogDebug($" {s}"));
}
Log.LogDebug("Selected Dependencies");
foreach (var library in librariesByType.Values.SelectMany(l => l))
{
Log.LogDebug($" {library.Identity}");
}
}
// Return the assembled dependency manager
return(new DependencyManager(graph, librariesByName, librariesByType));
}
public static ModuleModel FromAnalysis(IDocumentAnalysis analysis, IServiceContainer services, AnalysisCachingLevel options)
{
var uniqueId = analysis.Document.GetUniqueId(services, options);
if (uniqueId == null)
{
// Caching level setting does not permit this module to be persisted.
return(null);
}
var variables = new Dictionary <string, VariableModel>();
var functions = new Dictionary <string, FunctionModel>();
var classes = new Dictionary <string, ClassModel>();
var typeVars = new Dictionary <string, TypeVarModel>();
var namedTuples = new Dictionary <string, NamedTupleModel>();
// Go directly through variables which names are listed in GetMemberNames
// as well as variables that are declarations.
var exportedNames = new HashSet <string>(analysis.Document.GetMemberNames());
foreach (var v in analysis.GlobalScope.Variables
.Where(v => exportedNames.Contains(v.Name) ||
v.Source == VariableSource.Declaration ||
v.Source == VariableSource.Builtin ||
v.Source == VariableSource.Generic))
{
if (v.Value is IGenericTypeParameter && !typeVars.ContainsKey(v.Name))
{
typeVars[v.Name] = TypeVarModel.FromGeneric(v);
continue;
}
switch (v.Value)
{
case ITypingNamedTupleType nt:
namedTuples[nt.Name] = new NamedTupleModel(nt);
continue;
case IPythonFunctionType ft when ft.IsLambda():
// No need to persist lambdas.
continue;
case IPythonFunctionType ft when v.Name != ft.Name:
// Variable assigned to type info of the function like
// def func(): ...
// x = type(func)
break;
case IPythonFunctionType ft:
var fm = GetFunctionModel(analysis, v, ft);
if (fm != null && !functions.ContainsKey(ft.Name))
{
functions[ft.Name] = fm;
continue;
}
break;
case IPythonClassType cls when v.Name != cls.Name:
// Variable assigned to type info of the class.
break;
case IPythonClassType cls
when cls.DeclaringModule.Equals(analysis.Document) || cls.DeclaringModule.Equals(analysis.Document.Stub):
if (!classes.ContainsKey(cls.Name))
{
classes[cls.Name] = new ClassModel(cls);
continue;
}
break;
}
// Do not re-declare classes and functions as variables in the model.
if (!variables.ContainsKey(v.Name))
{
variables[v.Name] = VariableModel.FromVariable(v);
}
}
// Take dependencies from imports. If module has stub we should also take
// dependencies from there since persistent state is based on types that
// are combination of stub and the module. Sometimes stub may import more
// and we must make sure dependencies are restored before the module.
var primaryDependencyWalker = new DependencyWalker(analysis.Ast);
var stubDependencyWalker = analysis.Document.Stub != null ? new DependencyWalker(analysis.Document.Stub.Analysis.Ast) : null;
var stubImports = stubDependencyWalker?.Imports ?? Enumerable.Empty <ImportModel>();
var stubFromImports = stubDependencyWalker?.FromImports ?? Enumerable.Empty <FromImportModel>();
return(new ModuleModel {
Id = uniqueId.GetStableHash(),
UniqueId = uniqueId,
Name = analysis.Document.Name,
QualifiedName = analysis.Document.QualifiedName,
Documentation = analysis.Document.Documentation,
Functions = functions.Values.ToArray(),
Variables = variables.Values.ToArray(),
Classes = classes.Values.ToArray(),
TypeVars = typeVars.Values.ToArray(),
NamedTuples = namedTuples.Values.ToArray(),
NewLines = analysis.Ast.NewLineLocations.Select(l => new NewLineModel {
EndIndex = l.EndIndex,
Kind = l.Kind
}).ToArray(),
FileSize = analysis.Ast.EndIndex,
Imports = primaryDependencyWalker.Imports.ToArray(),
FromImports = primaryDependencyWalker.FromImports.ToArray(),
StubImports = stubImports.ToArray(),
StubFromImports = stubFromImports.ToArray()
});
}
public void EnumerateDatabase(string dbConnection, bool storeThreePartNames)
{
string serverName = string.Empty;
string loginName = string.Empty;
string password = string.Empty;
Server sqlServer;
ServerConnection sqlConnection;
Database sqlDatabase;
threePartNames = storeThreePartNames;
connectionStringBuilder.Clear();
connectionStringBuilder.ConnectionString = dbConnection;
try
{
sqlConnection = new ServerConnection(connectionStringBuilder.DataSource);
sqlConnection.ApplicationName = "DependencyAnalyzer";
if (connectionStringBuilder.IntegratedSecurity)
{
sqlConnection.LoginSecure = true;
}
else
{
sqlConnection.LoginSecure = false;
sqlConnection.Login = connectionStringBuilder.UserID;
sqlConnection.Password = connectionStringBuilder.Password;
}
sqlServer = new Server(sqlConnection);
sqlServer.SetDefaultInitFields(typeof(Table), "Name");
sqlServer.SetDefaultInitFields(typeof(Table), "Schema");
sqlServer.SetDefaultInitFields(typeof(Table), "IsSystemObject");
sqlServer.SetDefaultInitFields(typeof(View), "Name");
sqlServer.SetDefaultInitFields(typeof(View), "Schema");
sqlServer.SetDefaultInitFields(typeof(View), "IsSystemObject");
sqlServer.SetDefaultInitFields(typeof(StoredProcedure), "Name");
sqlServer.SetDefaultInitFields(typeof(StoredProcedure), "Schema");
sqlServer.SetDefaultInitFields(typeof(StoredProcedure), "IsSystemObject");
sqlServer.SetDefaultInitFields(typeof(UserDefinedFunction), "Name");
sqlServer.SetDefaultInitFields(typeof(UserDefinedFunction), "Schema");
sqlServer.SetDefaultInitFields(typeof(UserDefinedFunction), "IsSystemObject");
int connectionID = repository.GetConnection(connectionStringBuilder.ConnectionString);
if (connectionID == -1)
{
// Need to add a new connectionID.
connectionID = repository.AddObject("CMD " + connectionStringBuilder.InitialCatalog, string.Empty, Repository.OLEDBGuid, repository.RootRepositoryObjectID);
repository.AddAttribute(connectionID, Repository.Attributes.ConnectionString, connectionStringBuilder.ConnectionString);
repository.AddAttribute(connectionID, Repository.Attributes.ConnectionServer, connectionStringBuilder.DataSource);
repository.AddAttribute(connectionID, Repository.Attributes.ConnectionDatabase, connectionStringBuilder.InitialCatalog);
}
sqlDatabase = sqlServer.Databases[connectionStringBuilder.InitialCatalog];
if (sqlDatabase == null)
{
throw new Exception(String.Format("{0} database was not found on server {1}", connectionStringBuilder.InitialCatalog, sqlServer.Name));
}
String databaseName = connectionStringBuilder.InitialCatalog;
DependencyWalker findDepenency = new DependencyWalker(sqlServer);
List <SqlSmoObject> walkerList = new List <SqlSmoObject>();
SqlSmoObject[] walkerArray;
ScriptingOptions scriptOptions = new ScriptingOptions();
scriptOptions.AllowSystemObjects = false;
string objectName, parentName, objectServerName, objectDatabaseName;
int objectConnectionID = 0;
int tableID, parentID, arrayCounter;
DependencyTree dependTree;
DependencyTreeNode walkNode, parentNode;
Console.WriteLine("Enumerate the Tables and their Dependencies");
// Enumerate the Tables
arrayCounter = 0;
foreach (Table sqlTable in sqlDatabase.Tables)
{
if (!sqlTable.IsSystemObject)
{
walkerList.Add(sqlTable);
}
}
walkerArray = new SqlSmoObject[walkerList.Count];
foreach (SqlSmoObject smoObject in walkerList)
{
walkerArray[arrayCounter++] = smoObject;
}
if (walkerArray.Length > 0)
{
dependTree = findDepenency.DiscoverDependencies(walkerArray, DependencyType.Parents);
// Walk the tree
parentNode = dependTree.FirstChild;
do
{
objectName = FormatObjectName(parentNode.Urn); // "[" + parentNode.Urn.GetAttribute("Schema") + "].[" + parentNode.Urn.GetAttribute("Name") + "]";
tableID = repository.GetTable(connectionID, objectName, parentNode.Urn.Type);
if (parentNode.HasChildNodes)
{
// Point at the first dependency
walkNode = parentNode.FirstChild;
do
{
parentName = FormatObjectName(walkNode.Urn); // "[" + (String.IsNullOrEmpty(walkNode.Urn.GetAttribute("Schema")) ? "dbo" : walkNode.Urn.GetAttribute("Schema")) + "].[" + walkNode.Urn.GetAttribute("Name") + "]";
switch (walkNode.Urn.Type)
{
case "Table":
case "View":
parentID = repository.GetTable(connectionID, parentName, walkNode.Urn.Type);
break;
case "UserDefinedFunction":
parentID = repository.GetFunction(connectionID, parentName);
break;
case "StoredProcedure":
parentID = repository.GetProcedure(connectionID, parentName);
break;
case "PartitionScheme":
case "XmlSchemaCollection":
parentID = -1;
break;
default:
if (sqlDatabase.StoredProcedures.Contains(walkNode.Urn.GetAttribute("Name"), walkNode.Urn.GetAttribute("Schema")))
{
parentID = repository.GetProcedure(connectionID, parentName);
}
else if (sqlDatabase.UserDefinedFunctions.Contains(walkNode.Urn.GetAttribute("Name"), walkNode.Urn.GetAttribute("Schema")))
{
parentID = repository.GetFunction(connectionID, parentName);
}
else
{
Console.WriteLine("Warning: Unresolvable Dependency encountered in object {0} for object {1} of type {2}", objectName, parentName, walkNode.Urn.Type);
parentID = repository.GetTable(connectionID, parentName, "Unresolvable");
}
break;
}
if (parentID > -1)
{
repository.AddMapping(parentID, tableID);
}
walkNode = walkNode.NextSibling;
}while (walkNode != null);
}
parentNode = parentNode.NextSibling;
}while (parentNode != null);
}
Console.WriteLine("Enumerate the Views and their Dependencies");
walkerList.Clear();
arrayCounter = 0;
foreach (View sqlView in sqlDatabase.Views)
{
if (!sqlView.IsSystemObject)
{
walkerList.Add(sqlView);
}
}
walkerArray = new SqlSmoObject[walkerList.Count];
foreach (SqlSmoObject smoObject in walkerList)
{
walkerArray[arrayCounter++] = smoObject;
}
if (walkerArray.Length > 0)
{
dependTree = findDepenency.DiscoverDependencies(walkerArray, DependencyType.Parents);
// Walk the tree
parentNode = dependTree.FirstChild;
do
{
objectName = FormatObjectName(parentNode.Urn); // "[" + parentNode.Urn.GetAttribute("Schema") + "].[" + parentNode.Urn.GetAttribute("Name") + "]";
// The following is because we don't know the type of a view in the TSQLParser...
tableID = repository.GetTable(connectionID, objectName, parentNode.Urn.Type);
if (parentNode.HasChildNodes)
{
// Point at the first dependency
walkNode = parentNode.FirstChild;
do
{
parentName = FormatObjectName(walkNode.Urn); // "[" + walkNode.Urn.GetAttribute("Schema") + "].[" + walkNode.Urn.GetAttribute("Name") + "]";
objectServerName = walkNode.Urn.Parent.Parent.GetAttribute("Name");
objectDatabaseName = walkNode.Urn.Parent.GetAttribute("Name");
objectConnectionID = DetermineConnection(objectServerName, objectDatabaseName);
switch (walkNode.Urn.Type)
{
case "Synonym": // Synonym's look like tables in base T-SQL
case "Table":
case "View": // View's look like tables in base T-SQL
parentID = repository.GetTable(objectConnectionID, parentName, walkNode.Urn.Type);
break;
case "UserDefinedFunction":
parentID = repository.GetFunction(objectConnectionID, parentName);
break;
case "StoredProcedure":
parentID = repository.GetProcedure(objectConnectionID, parentName);
break;
case "PartitionScheme":
case "XmlSchemaCollection":
parentID = -1;
break;
default:
if (sqlDatabase.StoredProcedures.Contains(walkNode.Urn.GetAttribute("Name"), walkNode.Urn.GetAttribute("Schema")))
{
parentID = repository.GetProcedure(objectConnectionID, parentName);
}
else if (sqlDatabase.UserDefinedFunctions.Contains(walkNode.Urn.GetAttribute("Name"), walkNode.Urn.GetAttribute("Schema")))
{
parentID = repository.GetFunction(objectConnectionID, parentName);
}
else
{
Console.WriteLine("Warning: Unresolvable Dependency encountered in object {0} for object {1} of type {2}", objectName, walkNode.Urn, walkNode.Urn.Type);
Console.WriteLine("Attempting to locate via repository as table {0} on server {1} in database {2}", parentName, objectServerName, objectDatabaseName);
parentID = repository.GetTable(objectConnectionID, parentName, "Unresolved");
}
break;
}
if (parentID > -1)
{
repository.AddMapping(parentID, tableID);
}
walkNode = walkNode.NextSibling;
}while (walkNode != null);
}
parentNode = parentNode.NextSibling;
}while (parentNode != null);
}
Console.WriteLine("Enumerate the StoredProcedures and their Dependencies");
walkerList.Clear();
arrayCounter = 0;
foreach (StoredProcedure sqlProcedure in sqlDatabase.StoredProcedures)
{
if (!sqlProcedure.IsSystemObject)
{
walkerList.Add(sqlProcedure);
}
}
walkerArray = new SqlSmoObject[walkerList.Count];
foreach (SqlSmoObject smoObject in walkerList)
{
walkerArray[arrayCounter++] = smoObject;
}
if (walkerArray.Length > 0)
{
dependTree = findDepenency.DiscoverDependencies(walkerArray, DependencyType.Parents);
// Walk the tree
parentNode = dependTree.FirstChild;
do
{
objectName = FormatObjectName(parentNode.Urn); // "[" + parentNode.Urn.GetAttribute("Schema") + "].[" + parentNode.Urn.GetAttribute("Name") + "]";
tableID = repository.GetProcedure(connectionID, objectName);
if (parentNode.HasChildNodes)
{
// Point at the first dependency
walkNode = parentNode.FirstChild;
do
{
parentName = FormatObjectName(walkNode.Urn); // "[" + walkNode.Urn.GetAttribute("Schema") + "].[" + walkNode.Urn.GetAttribute("Name") + "]";
objectServerName = walkNode.Urn.Parent.Parent.GetAttribute("Name");
objectDatabaseName = walkNode.Urn.Parent.GetAttribute("Name");
objectConnectionID = DetermineConnection(objectServerName, objectDatabaseName);
switch (walkNode.Urn.Type)
{
case "Synonym": // Synonym's look like tables in base T-SQL
case "Table":
case "View": // View's look like tables in base T-SQL
parentID = repository.GetTable(objectConnectionID, parentName, walkNode.Urn.Type);
break;
case "UserDefinedFunction":
parentID = repository.GetFunction(objectConnectionID, parentName);
break;
case "StoredProcedure":
parentID = repository.GetProcedure(objectConnectionID, parentName);
break;
case "PartitionScheme":
case "XmlSchemaCollection":
parentID = -1;
break;
default:
if (sqlDatabase.StoredProcedures.Contains(walkNode.Urn.GetAttribute("Name"), walkNode.Urn.GetAttribute("Schema")))
{
parentID = repository.GetProcedure(objectConnectionID, parentName);
}
else if (sqlDatabase.UserDefinedFunctions.Contains(walkNode.Urn.GetAttribute("Name"), walkNode.Urn.GetAttribute("Schema")))
{
parentID = repository.GetFunction(objectConnectionID, parentName);
}
else
{
Console.WriteLine("Warning: Unresolvable Dependency encountered in object {0} for object {1} of type {2}", objectName, walkNode.Urn, walkNode.Urn.Type);
Console.WriteLine("Attempting to locate via repository as table {0} on server {1} in database {2}", parentName, objectServerName, objectDatabaseName);
parentID = repository.GetTable(objectConnectionID, parentName, "Unresolvable");
}
break;
}
if (parentID > -1)
{
repository.AddMapping(parentID, tableID);
}
walkNode = walkNode.NextSibling;
}while (walkNode != null);
}
parentNode = parentNode.NextSibling;
}while (parentNode != null);
}
Console.WriteLine("Enumerate the UserDefinedFunction and their Dependencies");
walkerList.Clear();
arrayCounter = 0;
foreach (UserDefinedFunction sqlFunctions in sqlDatabase.UserDefinedFunctions)
{
if (!sqlFunctions.IsSystemObject)
{
walkerList.Add(sqlFunctions);
}
}
walkerArray = new SqlSmoObject[walkerList.Count];
foreach (SqlSmoObject smoObject in walkerList)
{
walkerArray[arrayCounter++] = smoObject;
}
if (walkerArray.Length > 0)
{
dependTree = findDepenency.DiscoverDependencies(walkerArray, DependencyType.Parents);
// Walk the tree
parentNode = dependTree.FirstChild;
do
{
objectName = FormatObjectName(parentNode.Urn); // "[" + parentNode.Urn.GetAttribute("Schema") + "].[" + parentNode.Urn.GetAttribute("Name") + "]";
// The following is because we don't know the type of a view in the TSQLParser...
tableID = repository.GetFunction(connectionID, objectName);
if (parentNode.HasChildNodes)
{
// Point at the first dependency
walkNode = parentNode.FirstChild;
do
{
parentName = FormatObjectName(walkNode.Urn); // "[" + walkNode.Urn.GetAttribute("Schema") + "].[" + walkNode.Urn.GetAttribute("Name") + "]";
objectServerName = walkNode.Urn.Parent.Parent.GetAttribute("Name");
objectDatabaseName = walkNode.Urn.Parent.GetAttribute("Name");
objectConnectionID = DetermineConnection(objectServerName, objectDatabaseName);
switch (walkNode.Urn.Type)
{
case "Synonym": // Synonym's look like tables in base T-SQL
case "Table":
case "View": // View's look like tables in base T-SQL
parentID = repository.GetTable(objectConnectionID, parentName, walkNode.Urn.Type);
break;
case "UserDefinedFunction":
parentID = repository.GetFunction(objectConnectionID, parentName);
break;
case "StoredProcedure":
parentID = repository.GetProcedure(objectConnectionID, parentName);
break;
case "PartitionScheme":
case "XmlSchemaCollection":
parentID = -1;
break;
default:
if (sqlDatabase.StoredProcedures.Contains(walkNode.Urn.GetAttribute("Name"), walkNode.Urn.GetAttribute("Schema")))
{
parentID = repository.GetProcedure(objectConnectionID, parentName);
}
else if (sqlDatabase.UserDefinedFunctions.Contains(walkNode.Urn.GetAttribute("Name"), walkNode.Urn.GetAttribute("Schema")))
{
parentID = repository.GetFunction(objectConnectionID, parentName);
}
else
{
Console.WriteLine("Warning: Unresolvable Dependency encountered in object {0} for object {1} of type {2}", objectName, walkNode.Urn, walkNode.Urn.Type);
Console.WriteLine("Attempting to locate via repository as table {0} on server {1} in database {2}", parentName, objectServerName, objectDatabaseName);
parentID = repository.GetTable(objectConnectionID, parentName, "Unresolvable");
}
break;
}
if (parentID > -1)
{
repository.AddMapping(parentID, tableID);
}
walkNode = walkNode.NextSibling;
}while (walkNode != null);
}
parentNode = parentNode.NextSibling;
}while (parentNode != null);
}
walkerList.Clear();
arrayCounter = 0;
foreach (Synonym sqlSynonym in sqlDatabase.Synonyms)
{
objectName = FormatObjectName(sqlSynonym.Urn); // "[" + sqlSynonym.Urn.GetAttribute("Schema") + "].[" + sqlSynonym.Urn.GetAttribute("Name") + "]";
// The following is because we don't know the type of a synonym in the TSQLParser...
tableID = repository.GetTable(connectionID, objectName, sqlSynonym.Urn.Type);
objectServerName = (sqlSynonym.BaseServer == string.Empty) ? sqlServer.Name : sqlSynonym.BaseServer;
objectDatabaseName = sqlSynonym.BaseDatabase;
objectConnectionID = DetermineConnection(objectServerName, objectDatabaseName);
if (threePartNames)
{
parentName = String.Format("[{0}].[{1}].[{2}]", objectDatabaseName, ((sqlSynonym.BaseSchema == string.Empty) ? "dbo" : sqlSynonym.BaseSchema), sqlSynonym.BaseObject);
}
else
{
parentName = String.Format("[{0}].[{1}]", ((sqlSynonym.BaseSchema == string.Empty) ? "dbo" : sqlSynonym.BaseSchema), sqlSynonym.BaseObject);
}
#if SQL2005
// SQL 2005 doesn't support the BaseType, so assume it's a table on the other end.
parentID = repository.GetTable(objectConnectionID, parentName);
if (parentID > -1)
{
repository.AddMapping(parentID, tableID);
}
#else
switch (sqlSynonym.BaseType.ToString())
{
case "Synonym": // Synonym's look like tables in base T-SQL
case "Table":
case "View": // View's look like tables in base T-SQL
parentID = repository.GetTable(objectConnectionID, parentName, sqlSynonym.BaseType.ToString());
break;
case "UserDefinedFunction":
parentID = repository.GetFunction(objectConnectionID, parentName);
break;
case "StoredProcedure":
parentID = repository.GetProcedure(objectConnectionID, parentName);
break;
case "PartitionScheme":
case "XmlSchemaCollection":
parentID = -1;
break;
default:
// Asume that this is pointing at a table...
parentID = repository.GetTable(objectConnectionID, parentName, sqlSynonym.BaseType.ToString());
break;
}
if (parentID > -1)
{
repository.AddMapping(parentID, tableID);
}
#endif
}
}
catch (Exception err)
{
Console.WriteLine(string.Format("Could not enumerate the database: {0}", err.Message));
}
}
public bool Execute()
{
var projectCollection = new ProjectCollection();
var project = projectCollection.LoadProject(ProjectFile);
var providers = new List <IDependencyProvider>();
var packagesPath = GetPackagesPath();
// Handle MSBuild projects
providers.Add(new MSBuildDependencyProvider(projectCollection));
// Handle NuGet dependencies
providers.Add(new NuGetDependencyResolver(packagesPath));
var walker = new DependencyWalker(providers);
var name = project.GetPropertyValue("ProjectGuid");
var targetFramework = NuGetFramework.Parse(project.GetPropertyValue("TargetFrameworkMoniker"));
var version = new NuGetVersion(new Version());
var searchCriteria = GetSelectionCriteria(targetFramework);
// This is so that we have a unique cache per target framework
var root = walker.Walk(name, version, targetFramework);
Logger.WriteInformation("Unresolved closure".Yellow());
// Raw graph
root.Dump(Logger.WriteInformation);
// Cousin resolution
root.TryResolveConflicts();
Logger.WriteInformation("Unified closure".Yellow());
// Dump dependency graph after resolution
root.Dump(Logger.WriteInformation);
var resolvedItems = new Dictionary <string, GraphItem <ResolveResult> >();
// Pick the relevant versions of the package after conflict
// resolution
root.ForEach(true, (node, state) =>
{
if (state == false ||
node.Disposition != Disposition.Accepted ||
node.Item == null)
{
return(false);
}
if (!resolvedItems.ContainsKey(node.Key.Name))
{
resolvedItems[node.Key.Name] = node.Item;
}
return(true);
});
var seen = new HashSet <string>();
var queue = new Queue <ResolveResult>();
// The reason we don't just look the packages as a flat list is because we'll need to
// eventually handle private dependencies which require knowledge of the graph
queue.Enqueue(resolvedItems[name].Data);
while (queue.Count > 0)
{
var top = queue.Dequeue();
if (!seen.Add(top.LibraryDescription.Identity.Name))
{
continue;
}
if (top.DependencyProvider is NuGetDependencyResolver)
{
DumpPackageContents(top.LibraryDescription, searchCriteria);
}
foreach (var dependency in top.LibraryDescription.Dependencies)
{
GraphItem <ResolveResult> dependencyItem;
if (resolvedItems.TryGetValue(dependency.Name, out dependencyItem))
{
queue.Enqueue(dependencyItem.Data);
}
}
}
return(true);
}
