/// <summary>
/// CONVERSION: Creates a NodeGraphLink, given an XML Serialized copy of the link and a view
/// </summary>
/// <param name="p_TreeNode"></param>
/// <param name="p_View"></param>
public NodeGraphLink(ConnectionDescriptor connection, NodeGraphView p_View)
{
int v_InputNodeId = connection.sourceModule;
int v_OutputNodeId = connection.destinationModule;
int v_InputNodeConnectorIdx = connection.sourcePort;
int v_OutputNodeConnectorIdx = connection.destinationPort;
if (v_InputNodeId != 0x0FFFFFFF)
{
//this.m_InputConnector = p_View.NodeCollection[v_InputNodeId].Connectors[v_InputNodeConnectorIdx];
this.m_InputConnector = p_View.NodeCollection[v_InputNodeId].GetConnector(v_InputNodeConnectorIdx, ConnectorType.OutputConnector);
}
else
{
this.m_InputConnector = p_View.NodeConnectorCollection[v_InputNodeConnectorIdx];
}
if (v_OutputNodeId != 0x0FFFFFFF)
{
//this.m_OutputConnector = p_View.NodeCollection[v_OutputNodeId].Connectors[v_OutputNodeConnectorIdx];
this.m_OutputConnector = p_View.NodeCollection[v_OutputNodeId].GetConnector(v_OutputNodeConnectorIdx, ConnectorType.InputConnector);
}
else
{
this.m_OutputConnector = p_View.NodeConnectorCollection[v_OutputNodeConnectorIdx];
}
}
/// <summary>
/// processing of execution - main method of action
/// </summary>
/// <returns> </returns>
protected override object MainProcess() {
var c = new ConnectionDescriptor {Name = name, ConnectionString = connection};
Application.DatabaseConnections.Register(
c, !temporal
);
return c;
}
public PetapocoDbContext(List <IFileLoader> sqlLoader, ConnectionDescriptor connection) : base(sqlLoader, connection)
{
this.db = new Database(connection.ConnectionString, connection.ProviderName);
this.db.OpenSharedConnection();
this.db.EnableAutoSelect = false;
this.db.EnableNamedParams = true;
this.db.CommandTimeout = 30;
}
public static void SetConfig()
{
var defaultLocation = new ConfigLocationHelper();
var sqlLoader = new FileSqlLoader(defaultLocation.SQLStatement);
connDesc = DBContextHelper.Instance.getConfiguration();
dbManager = new PetaPocoContextManager(new[] { sqlLoader }, new[] { connDesc });
dbManager.SetContextExecutionMode(DBContextExecutionMode.ByName);
}
/// <summary>
/// Считывает соединения из штатного конфига
/// </summary>
/// <returns></returns>
public IEnumerable<ConnectionDescriptor> GetConnections() {
var connections = ConfigurationManager.ConnectionStrings;
foreach (ConnectionStringSettings connection in connections) {
var con = new ConnectionDescriptor
{Name = connection.Name, ConnectionString = connection.ConnectionString, ConnectionType = typeof (SqlConnection)};
con.Evidence = "config:" + connection.ElementInformation.Source + ":" + connection.ElementInformation.LineNumber;
yield return con;
}
}
public static byte[] CreateConnectionAcceptFrame()
{
var descriptor = new ConnectionDescriptor
{
ProtocolVersion = ProtocolVersion,
MaxFrameSize = MaxFrameSize
};
return(_createFrame(FrameType.ConnectionAccept, BsonCodec.Encode(descriptor)));
}
/// <summary>
/// Зарегистрировать соединение с БД (создает файл)
/// </summary>
public void Register(ConnectionDescriptor connectionDescriptor)
{
var filename = GetFileName(connectionDescriptor.Name);
Directory.CreateDirectory(Path.GetDirectoryName(filename));
var str = string.Format("{0} '{1}' '{2}'", connectionDescriptor.Name, connectionDescriptor.ConnectionType.AssemblyQualifiedName,
connectionDescriptor.ConnectionString);
File.WriteAllText(filename, str);
}
/// <summary>
/// processing of execution - main method of action
/// </summary>
/// <returns> </returns>
protected override object MainProcess()
{
var c = new ConnectionDescriptor {
Name = name, ConnectionString = connection
};
Application.DatabaseConnections.Register(
c, !temporal
);
return(c);
}
public static byte[] CreateConnectionStartFrame(Dictionary <string, string> data = null)
{
var descriptor = new ConnectionDescriptor
{
ProtocolVersion = ProtocolVersion,
MaxFrameSize = MaxFrameSize,
Data = data
};
return(_createFrame(FrameType.ConnectionStart, BsonCodec.Encode(descriptor)));
}
public static byte[] CreateConnectionRejectFrame(string error = null)
{
var descriptor = new ConnectionDescriptor
{
ProtocolVersion = ProtocolVersion,
MaxFrameSize = MaxFrameSize,
Error = error
};
return(_createFrame(FrameType.ConnectionReject, BsonCodec.Encode(descriptor)));
}
public override IDataCommand GetDatabase(string name)
{
if (!string.IsNullOrEmpty(name))
{
ConnectionDescriptor connection = base.GetConnection(name);
if (connection != null)
{
return(new PetapocoDbContext(base.SqlLoader, connection));
}
}
return(null);
}
/// <summary>
/// ќбходит компоненты контейнера и находит все IDbConnection
/// </summary>
/// <returns></returns>
public IEnumerable<ConnectionDescriptor> GetConnections() {
foreach (var source in Container.GetComponents().Where(x=>x.ServiceType==typeof(IDbConnection))) {
if(source.Name.IsEmpty()) continue;
var con = new ConnectionDescriptor();
con.Name = source.Name.Split('.', '/')[0];
con.InstantiateWithContainer = true;
con.Container = this.Container;
con.ContainerName = source.Name;
con.Evidence = "app.container";
yield return con;
}
}
/// <summary>
/// Creates custom metrics:
/// GeoServerIsRunningMetric - which does a layer
/// description call to a geoserver.
/// SqlServerIsRunningMetric - which opens a database connection to a sqlserver
/// </summary>
public AppHealth() : base("NYU_NYCHANIS")
{
const string server = "http://207.245.89.220:8080/geoserver/wms";
const string ver = "1.1.1";
const string layer = "fc:boroughs";
AddMetric(new GeoServerIsRunningMetric(server, layer, ver));
// Add metric that opens a sql server connection
AbstractSqlConnectionDescriptor conn = (AbstractSqlConnectionDescriptor)ConnectionDescriptor.LoadFromConfig(new Config("PDP.Data"), "PDB", Hasher.Decrypt);
AddMetric(new DbConnectionMetric(conn));
}
/// <summary>
/// Зарегистрировать новое соединение
/// </summary>
public void Register(ConnectionDescriptor connectionDescriptor, bool persistent)
{
lock (this) {
Registry[connectionDescriptor.Name] = connectionDescriptor;
if (persistent)
{
foreach (var persister in Persisters)
{
persister.Register(connectionDescriptor);
}
}
}
}
public ConnectionDescriptor getConfiguration()
{
var defaultLocation = new ConfigLocationHelper();
ConnectionDescriptor connDesc = new ConnectionDescriptor();
String binderLabel = "Database";
ConfigurationCabinet connCab = new ConfigurationCabinet("Application Configuration");
//string DevCode = ApplicationSettings.Instance.Development.Stage.Code;
//string DevCode = "PRD";
String DevCode = GetConfigList(binderLabel);
IConfigurationBinder iconBin = new DifferentialXmlConfigurationBinder(binderLabel, DevCode, defaultLocation.Configuration);
connCab.AddBinderAndLoad(iconBin);
//ApplicationConfigurationCabinet.Instance.AddBinderAndLoad(new DifferentialXmlConfigurationBinder(binderLabel,
//ApplicationSettings.Instance.Development.Stage.Code, defaultLocation.Configuration));
IConfigurationBinder configurationBinder = connCab.GetBinder(binderLabel);
ConfigurationItem[] configurations = configurationBinder.GetConfigurations();
if (configurations != null)
{
var compositeConfigItem = configurations
.FirstOrDefault(config => ((CompositeConfigurationItem)config)
.GetItem("IsDefault").Value.ToLower() == "true") as CompositeConfigurationItem;
if (compositeConfigItem != null)
{
connDesc.ConnectionString = compositeConfigItem.GetItem("ConnectionString").Value;
connDesc.ProviderName = compositeConfigItem.GetItem("Provider").Value;
connDesc.Name = compositeConfigItem.Key;
connDesc.IsDefault = Convert.ToBoolean(compositeConfigItem.GetItem("IsDefault").Value);
if (String.IsNullOrEmpty(connDesc.ConnectionString))
{
throw new InvalidOperationException("ConnectionSetting is not properly set.");
}
if (String.IsNullOrEmpty(connDesc.ProviderName))
{
throw new InvalidOperationException("Provider is not properly set.");
}
}
else
{
throw new InvalidOperationException("Database-DEV.config is not properly set.");
}
}
return(connDesc);
}
/// <summary>
/// Считывает соединения из штатного конфига
/// </summary>
/// <returns></returns>
public IEnumerable <ConnectionDescriptor> GetConnections()
{
var connections = ConfigurationManager.ConnectionStrings;
foreach (ConnectionStringSettings connection in connections)
{
var con = new ConnectionDescriptor
{
Name = connection.Name, ConnectionString = connection.ConnectionString, ConnectionType = typeof(SqlConnection)
};
con.Evidence = "config:" + connection.ElementInformation.Source + ":" + connection.ElementInformation.LineNumber;
yield return(con);
}
}
/// <summary>
/// Считывает соединения из всех файлов с расширением *.db-connection
/// </summary>
/// <returns></returns>
public IEnumerable<ConnectionDescriptor> GetConnections() {
if(null==Files)yield break;
var configdir = Path.Combine(Files.Root, ".config");
if(!Directory.Exists(configdir))yield break;
var connectiFiles = Directory.GetFiles(configdir, "*.db-connection", SearchOption.AllDirectories);
IList<XElement> xcons = new List<XElement>();
foreach (var connectiFile in connectiFiles) {
var content = File.ReadAllText(connectiFile);
if(content.StartsWith("<")) {
xcons.Add(XElement.Parse(content));
continue;
}
if(null==Bxl) {
throw new QorpentException("cannot use bxl due to it is not found");
}
xcons.Add(Bxl.Parse(content,connectiFile));
}
foreach (var xcon in xcons) {
var set = new[] {xcon};
if(xcon.Elements().Any()) {
set = xcon.Elements().ToArray();
}
foreach (var e in set) {
var desc = new ConnectionDescriptor { Name = e.Name.LocalName, ConnectionString = e.Attr("name") };
var connectiontype = e.Attr("code");
if (desc.ConnectionString.IsEmpty() && connectiontype.IsNotEmpty())
{
desc.ConnectionString = connectiontype;
connectiontype = "auto";
}
if (connectiontype == "mssql" || connectiontype == "auto")
{
desc.ConnectionType = typeof(SqlConnection);
}
else if(connectiontype=="pgsql") {
var type = Type.GetType("Npgsql.NpgsqlConnection, Npgsql");
desc.ConnectionType = type;
}
else
{
desc.ConnectionType = Type.GetType(connectiontype);
}
desc.Evidence = e.Attr("_file");
yield return desc;
}
}
}
internal static NodeGraphLink FromConnectionDescriptor(ConnectionDescriptor connection, NodeGraphView nodeGraphView)
{
// string className = typeof(NodeGraphLink).Name;
//
// object[] arguments = { connection, nodeGraphView};
//
// System.Reflection.Assembly v_Assembly = System.Reflection.Assembly.GetExecutingAssembly();
//
// object v_Out = v_Assembly.CreateInstance(className, false,
// System.Reflection.BindingFlags.CreateInstance,
// null,
// arguments, System.Globalization.CultureInfo.GetCultureInfo("en-us"),
// null);
//
return(new NodeGraphLink(connection, nodeGraphView));
}
/// <summary>
/// ќбходит компоненты контейнера и находит все IDbConnection
/// </summary>
/// <returns></returns>
public IEnumerable <ConnectionDescriptor> GetConnections()
{
foreach (var source in Container.GetComponents().Where(x => x.ServiceType == typeof(IDbConnection)))
{
if (source.Name.IsEmpty())
{
continue;
}
var con = new ConnectionDescriptor();
con.Name = source.Name.Split('.', '/')[0];
con.InstantiateWithContainer = true;
con.Container = this.Container;
con.ContainerName = source.Name;
con.Evidence = "app.container";
yield return(con);
}
}
public async Task Open_EnsureConnection()
{
string sessionid = "temp session";
ConnectionDescriptor descriptor = new ConnectionDescriptor(new Uri("http://localhost"));
var pipeline = CreatePipeline(
(next, ctxt) =>
{
ctxt.ServerConnection = descriptor;
ctxt.ActionResult = "result value";
return(next(ctxt));
});
SetupSessionHandler(sessionid);
var proxy = CreateProxy(pipeline);
var openResult = await proxy.OpenSession("param");
Assert.Equal(ProxyState.Open, ProxyState.Open);
Assert.Equal("result value", openResult);
SessionHandler.Verify();
}
private void LoadContainer()
{
if (null == Container.FindComponent(typeof(IHostConfigProvider), null))
{
Container.Register(Container.NewComponent <IHostConfigProvider, HostServer>(implementation: this));
}
if (null == Container.FindComponent(typeof(IConfigProvider), null))
{
Container.Register(Container.NewComponent <IConfigProvider, HostServer>(implementation: this));
}
var loader = Container.GetLoader();
if (Directory.Exists(Config.ConfigFolder))
{
var xml = new XElement("result");
var bxl = new BxlParser();
foreach (var file in Directory.GetFiles(Config.ConfigFolder, "*.ioc-manifest.bxl"))
{
if (Config.IsConfigFileMatch(file))
{
var filexml = bxl.Parse(File.ReadAllText(file));
xml.Add(filexml.Elements());
}
}
loader.LoadManifest(xml, true);
}
if (0 != Config.ConnectionStrings.Count)
{
var connections = Container.Get <IDatabaseConnectionProvider>();
if (null == connections)
{
throw new Exception("No connection provider");
}
foreach (var cs in Config.ConnectionStrings)
{
var dsc = new ConnectionDescriptor {
ConnectionString = cs.Value,
Name = cs.Key,
PresereveCleanup = true
};
connections.Register(dsc, false);
}
}
loader.LoadAssembly(typeof(HostServer).Assembly);
loader.LoadAssembly(typeof(HttpAuthenticator).Assembly);
loader.LoadAssembly(typeof(ReportProvider).Assembly);
foreach (var assemblyName in Config.AutoconfigureAssemblies)
{
Assembly assembly = null;
if (assemblyName.Contains("/") || assemblyName.Contains("\\"))
{
var file = EnvironmentInfo.ResolvePath(assemblyName);
var dir = Path.GetDirectoryName(file);
ResolveEventHandler h = (s, a) => {
var name = a.Name.Split(',')[0];
var path = Path.Combine(dir, name + ".dll");
if (File.Exists(path))
{
var bytes = File.ReadAllBytes(path);
return(Assembly.Load(bytes));
}
return(null);
};
AppDomain.CurrentDomain.AssemblyResolve += h;
assembly = Assembly.Load(File.ReadAllBytes(file));
}
else
{
assembly = Assembly.Load(assemblyName);
}
loader.LoadAssembly(assembly);
}
}
/// <summary>
/// Считывает соединения из всех файлов с расширением *.db-connection
/// </summary>
/// <returns></returns>
public IEnumerable <ConnectionDescriptor> GetConnections()
{
if (null == Files)
{
yield break;
}
var configdir = Path.Combine(Files.Root, ".config");
if (!Directory.Exists(configdir))
{
yield break;
}
var connectiFiles = Directory.GetFiles(configdir, "*.db-connection", SearchOption.AllDirectories);
IList <XElement> xcons = new List <XElement>();
foreach (var connectiFile in connectiFiles)
{
var content = File.ReadAllText(connectiFile);
if (content.StartsWith("<"))
{
xcons.Add(XElement.Parse(content));
continue;
}
if (null == Bxl)
{
throw new QorpentException("cannot use bxl due to it is not found");
}
xcons.Add(Bxl.Parse(content, connectiFile));
}
foreach (var xcon in xcons)
{
var set = new[] { xcon };
if (xcon.Elements().Any())
{
set = xcon.Elements().ToArray();
}
foreach (var e in set)
{
var desc = new ConnectionDescriptor {
Name = e.Name.LocalName, ConnectionString = e.Attr("name")
};
var connectiontype = e.Attr("code");
if (desc.ConnectionString.IsEmpty() && connectiontype.IsNotEmpty())
{
desc.ConnectionString = connectiontype;
connectiontype = "auto";
}
if (connectiontype == "mssql" || connectiontype == "auto")
{
desc.ConnectionType = typeof(SqlConnection);
}
else if (connectiontype == "pgsql")
{
var type = Type.GetType("Npgsql.NpgsqlConnection, Npgsql");
desc.ConnectionType = type;
}
else
{
desc.ConnectionType = Type.GetType(connectiontype);
}
desc.Evidence = e.Attr("_file");
yield return(desc);
}
}
}
/// <summary>
/// Зарегистрировать новое соединение
/// </summary>
public void Register(ConnectionDescriptor connectionDescriptor, bool persistent) {
lock(this) {
Registry[connectionDescriptor.Name] = connectionDescriptor;
if(persistent) {
foreach (var persister in Persisters) {
persister.Register(connectionDescriptor);
}
}
}
}
public void Register(ConnectionDescriptor connectionDescriptor, bool persistent) {
throw new NotImplementedException();
}
public async Task Open_EnsureConnection()
{
string sessionid = "temp session";
ConnectionDescriptor descriptor = new ConnectionDescriptor(new Uri("http://localhost"));
var pipeline = CreatePipeline(
(next, ctxt) =>
{
ctxt.ServerConnection = descriptor;
ctxt.ActionResult = "result value";
return next(ctxt);
});
SetupSessionHandler(sessionid);
var proxy = CreateProxy(pipeline);
var openResult = await proxy.OpenSession("param");
Assert.Equal(ProxyState.Open, ProxyState.Open);
Assert.Equal("result value", openResult);
SessionHandler.Verify();
}
public void Register(ConnectionDescriptor connectionDescriptor, bool persistent)
{
throw new NotImplementedException();
}
