private void EditInstanceButton_Click(object sender, EventArgs e)
{
if (!String.IsNullOrEmpty(_cbInProcessInstanceName.Text))
{
InstanceConfiguration configuration = InstanceManager.LoadConfiguration();
ServerConfiguration instance = configuration.Instances[_cbInProcessInstanceName.Text];
if (instance == null)
{
instance = new ServerConfiguration();
instance.Name = _cbInProcessInstanceName.Text;
}
else
{
configuration.Instances.Remove(instance.Name);
}
instance = EditInstanceForm.ExecuteEdit(instance);
configuration.Instances.Add(instance);
InstanceManager.SaveConfiguration(configuration);
_localInstancesEnumerated = false;
LoadInstances(configuration);
_cbInProcessInstanceName.Text = instance.Name;
}
}
private void configureButton_Click(object sender, System.EventArgs args)
{
InstanceConfiguration configuration = InstanceManager.LoadConfiguration();
ServerConfiguration instance = configuration.Instances[cbInstance.Text];
if (instance == null)
{
instance = ServerConfiguration.DefaultInstance(cbInstance.Text);
}
else
{
configuration.Instances.Remove(instance.Name);
}
try
{
instance = EditInstanceForm.ExecuteEdit(instance);
configuration.Instances.Add(instance);
InstanceManager.SaveConfiguration(configuration);
LoadInstances(configuration);
cbInstance.SelectedItem = instance.Name;
}
catch (AbortException)
{
}
}
public InstanceConnectionControl(InstanceConfiguration config, IList <InstanceConfiguration> instances)
{
InitializeComponent();
Config = config;
Instances = instances.ToList();
DataContext = config;
}
public ActionResult CreateInstance([Bind(Include = "Name")] InstanceCreate instance)
{
if (ModelState.IsValid)
{
var config = new InstanceConfiguration {
DisplayName = instance.Name, BackgroundColor = "rgba(0,0,0,1)"
};
db.InstanceConfigurations.Add(config);
db.SaveChanges();
var usr = Generic.GetUserName();
var inst = new Instance
{
Name = instance.Name,
Creator = usr,
CreationDate = DateTime.Now,
Members = new List <Member>(),
Active = true,
InstanceConfigurationID = config.InstanceConfigurationID
};
db.Instances.Add(inst);
db.SaveChanges();
var layer = new Layer(new CreateLayer {
InstanceID = inst.InstanceID, Name = "Default"
});
var mem = new Member {
UserName = usr, InstanceID = inst.InstanceID
};
db.Layers.Add(layer);
db.Members.Add(mem);
db.SaveChanges();
return(Json(new { refresh = true }));
}
return(Json(new { error = Generic.GetValidationErrors(ModelState) }));
}
public void CanSetPackageTypeOptionFromAString(string configCommand)
{
var configFileStream = new MemoryStream();
var fileSystem = new Mock <IFileSystem>();
IDictionary <string, MockFileData> fileData = new Dictionary <string, MockFileData>()
{
{ "c:\\config.json", new MockFileData("{\"PackageType\":0,\"PackageSource\":\"http://192.168.20.25:1337/nuget/justgivingapplications\",\"InstallRoot\":\"d:\\wwwcom\"}") }
};
fileSystem.SetupGet(x => x.Path).Returns(new MockPath(new MockFileSystem(fileData)));
fileSystem.SetupGet(x => x.File).Returns(new MockFile(new MockFileSystem(fileData)));
var appFolderLocator = new Mock <IApplicationFolderLocator>();
appFolderLocator.SetupGet(x => x.ApplicationFolder).Returns("c:\\");
fileSystem.Setup(x => x.File.Open(It.IsAny <string>(), FileMode.Create, FileAccess.Write)).Returns(configFileStream);
IInstanceConfiguration instanceConfiguration = new InstanceConfiguration()
{
SetConfigurationValue = configCommand
};
var deploydConfiguration = new DeploydConfiguration();
var configurationManager = new DeploydConfigurationManager(fileSystem.Object, appFolderLocator.Object);
TextWriter output = new StringWriter(new StringBuilder());
var command = new deployd.Features.AppConfiguration.ConfigureCommand(instanceConfiguration,
configurationManager, output);
command.Execute();
Assert.That(deploydConfiguration.PackageType, Is.EqualTo(PackageType.NuGet));
}
public bool TryDeleteInstance(InstanceConfiguration instanceConfiguration)
{
var instanceName = instanceConfiguration.Name;
_logger.LogInformation("Instance is being Deleted. Instance Name: {Name}", instanceName);
var directoryPath = Directory.GetCurrentDirectory();
string originalSourceFolderName = _config.GetValue <string>("OriginalSourceFolderName");
string instancePath = $"{directoryPath}\\..\\{originalSourceFolderName}_{instanceName}";
if (TryDeleteInstanceFolder(instancePath) == false)
{
return(false);
}
if (DoesDatabaseExist(instanceName))
{
using var sqlConnection = new SqlConnection($"Server=(localdb)\\mssqllocaldb;Trusted_Connection=True;MultipleActiveResultSets=true");
sqlConnection.Open();
var sqlCommandText = @"ALTER DATABASE " + instanceName + @" SET SINGLE_USER WITH ROLLBACK IMMEDIATE;DROP DATABASE [" + instanceName + "]";
var sqlCommand = new SqlCommand(sqlCommandText, sqlConnection);
sqlCommand.ExecuteNonQuery();
sqlConnection.Close();
}
_logger.LogInformation("Instance was successfully Deleted. Instance Name: {Name}", instanceName);
return(true);
}
protected async virtual Task ProcessPacket(IWebSocketClient client, string header, string content)
{
_logger.Write(LogType.Normal, "Pack(" + header + "): " + content + "\r\n");
try
{
// implement json parse error exception so that we dont crash the entire app but only disconnect this client
var data = JsonParser.Parse <JsonObject>(content);
if (header == "new")
{
var packageName = data.GetMember <JsonString>("packageName").Value;
var instanceConfiguration = InstanceConfiguration.CreateDefault(_settings);
var instanceId = _hostClient.CreateInstance(
packageName,
instanceConfiguration);
await Broadcast("new", new
{
instanceId = instanceId,
packageName = packageName
});
}
}
catch (Framework.Json.JsonException ex)
{
_logger.Write(
LogType.Error,
$"[{header}] Json protocol error: ({ex.GetType().Name}) '{ex.Message}' in packet: {content}");
}
}
public Type DataType(InstanceConfiguration instance, IList <InstanceConfiguration> instances)
{
var filtered = instances.ToList();
filtered.Remove(instance);
#region helper func
Type getInputDataType(InputConfiguration inConfig)
{
var remote = filtered.SingleOrDefault(r => r.Guid == inConfig.Remote);
if (remote is null)
{
return(null);
}
var remoteDesc = ConfigurationManager.Description(remote);
var remoteOutDesc = remoteDesc.Outputs.Single(o => o.Name == inConfig.Output.PropertyName);
switch (remoteOutDesc)
{
case VirtualPortDescription vRemoteOutDesc:
return(vRemoteOutDesc.DataType(remote, filtered));
case StaticPortDescription sRemoteOutDesc:
return(sRemoteOutDesc.DataType);
default:
throw new InvalidOperationException();
}
}
#endregion
switch (PortType)
{
case PortType.Input: // determin by remote output type
var inConfig = instance.Inputs.Single(c => c.Input.PropertyName == Name);
return(getInputDataType(inConfig));
case PortType.Output:
switch (instance)
{
case OperatorConfiguration opConfig:
var inputTypes = instance.Inputs.Select(i => getInputDataType(i)).ToArray();
if (inputTypes.Any(t => t is null))
{
return(null);
}
return(opConfig.OutputDataType(inputTypes));
case StreamReaderConfiguration inporterConfig:
return(typeof(Any));
default:
throw new InvalidOperationException();
}
default:
throw new InvalidOperationException();
}
}
private void ButtonYes_Click(object sender, RoutedEventArgs e)
{
if (DataGridComponents.SelectedItem is ComponentDescription desc)
{
Result = (InstanceConfiguration)desc.ConfigurationType.GetConstructor(Type.EmptyTypes).Invoke(null);
DialogResult = true;
}
}
public Entity(InstanceConfiguration configuration)
{
Id = configuration.Id;
Ip = configuration.Gate.Host.Ip;
Port = configuration.Gate.Host.Port;
Name = configuration.Gate.Name;
Status = GateStatus.Online;
}
public static WrappedBaseObjectState Create
(ISystemContext context, BaseObjectState source, InstanceConfiguration dataSourceConfiguration)
{
WrappedBaseObjectState ret = new WrappedBaseObjectState(source.Parent);
ret.Initialize(context, source);
return(ret);
}
private void LoadInstances(InstanceConfiguration configuration)
{
cbInstance.Items.Clear();
foreach (ServerConfiguration instance in configuration.Instances.Values)
{
cbInstance.Items.Add(instance.Name);
}
}
internal static WrappedMethodState Create
(ISystemContext context, MethodState source, InstanceConfiguration dataSourceConfiguration)
{
WrappedMethodState ret = new WrappedMethodState(source.Parent);
ret.Initialize(context, source);
return(ret);
}
public ServerInstance(string key, InstanceConfiguration instanceConfig, IConfiguration configuration,
ILogger <UpdateProviderJenkins> jenkinsLogger, ServersConfiguration serversConfiguration,
ILogger <ServerInstance> logger, IBackgroundTaskQueue taskQueue, ILogger <UpdateProviderLocal> localLogger,
ILogger <UpdateProviderGit> gitLogger)
{
Key = key;
_instanceConfig = instanceConfig;
_configuration = configuration;
_serversConfiguration = serversConfiguration;
_logger = logger;
_taskQueue = taskQueue;
switch (instanceConfig.UpdateType)
{
case "Jenkins":
var jenkinsConfig = configuration
.GetSection($"Servers:Instances:{key}:Updates")
.Get <UpdateProviderJenkinsConfiguration>();
_updateProvider = new UpdateProviderJenkins(jenkinsConfig, jenkinsLogger);
break;
case "Local":
var localConfig = configuration
.GetSection($"Servers:Instances:{key}:Updates")
.Get <UpdateProviderLocalConfiguration>();
_updateProvider = new UpdateProviderLocal(this, localConfig, localLogger, configuration);
break;
case "Git":
var gitConfig = configuration
.GetSection($"Servers:Instances:{key}:Updates")
.Get <UpdateProviderGitConfiguration>();
_updateProvider = new UpdateProviderGit(this, gitConfig, gitLogger, configuration);
break;
case "Dummy":
_updateProvider = new UpdateProviderDummy();
break;
case null:
_updateProvider = null;
break;
default:
throw new ArgumentException($"Unknown update type: {instanceConfig.UpdateType}");
}
if (!Directory.Exists(InstanceDir))
{
Directory.CreateDirectory(InstanceDir);
_logger.LogInformation($"Created InstanceDir {InstanceDir}");
}
LoadData();
}
public InstanceBasicsControl(InstanceConfiguration config)
{
InitializeComponent();
Config = config;
DataContext = config;
TextBlockComponent.Text = Desc.Name;
TextBlockDescription.Text = Desc.Description;
}
public VariableMediator(BaseVariableState variable, InstanceConfiguration dataSourceConfiguration)
{
m_variable = variable;
//TODO MOdelCompiler assigns wrong value for AccessLevel, so we use UserAccessLevel that van be assigned in the model.
variable.AccessLevel = variable.UserAccessLevel;
m_variable.OnWriteValue = new NodeValueEventHandler(My_OnNodeWriteEventHandler);
m_variable.OnStateChanged = new NodeStateChangedHandler(My_OnDeleteEventHandler);
GetBindings(variable, dataSourceConfiguration);
}
private static string StoreName(InstanceConfiguration instConfig, PortConfiguration portConfig)
{
var name = $"{instConfig.Name}:{portConfig.PropertyName}";
if (portConfig.Indexer != null)
{
name += $"[{portConfig.Indexer}]";
}
return(name);
}
public PogoInstance(InstanceConfiguration configuration)
{
this.Configuration = configuration;
this.Database = new PogoDB(this.Configuration.Name);
this.Walker = new Walker(this.Configuration.Name, this.Configuration.WalkingPoints);
this.GymHandler = new GymHandler(this);
this.PokemonHandler = new PokemonHandler(this);
}
public PogoInstance(InstanceConfiguration configuration, Session session, Walker walker)
{
this.Configuration = configuration;
this.Session = session;
this.Walker = walker;
this.GymHandler = new GymHandler(this);
this.PokemonHandler = new PokemonHandler(this);
this.Session.Map.Update += Map_Update;
}
private void LoadInstances(InstanceConfiguration configuration)
{
_localInstancesEnumerated = true;
InstanceList instances = configuration.Instances;
_cbInProcessInstanceName.Items.Clear();
for (int index = 0; index < instances.Count; index++)
{
_cbInProcessInstanceName.Items.Add(instances[index].Name);
}
}
public Instance AddModuleInstance(ModuleEnum module, InstanceConfiguration instanceConfiguration)
{
try
{
return(_instanceRepository.AddModuleInstance(module, instanceConfiguration));
}
catch (Exception e)
{
throw e;
}
}
public Instance(InstanceManager instanceManager, string id, Package package, ILogger logger, IBindingInterface bindingInterface, ISettings settings)
{
_instanceManager = instanceManager;
_id = id;
_package = package;
_logger = logger;
_bindingInterface = bindingInterface;
_status = InstanceStatus.Idle;
Configuration = InstanceConfiguration.CreateDefault(settings);
}
/// <summary>
/// Creates a new instance monitor.
/// </summary>
public InstanceMonitor(TileApiConfiguration apiConfiguration, InstanceConfiguration instanceConfiguration, ApiBootstrapper.InstanceLoaderDelegate instanceLoader)
{
_filesToMonitor = new List <FileMonitor>();
_hasChanged = false;
_lastChange = DateTime.Now.Ticks;
_reloadDelegate = instanceLoader;
_apiConfiguration = apiConfiguration;
_instanceConfiguration = instanceConfiguration;
_timer = new Timer(Tick, null, System.Threading.Timeout.Infinite, System.Threading.Timeout.Infinite);
}
public void WhenInstallPathIsParameterisedAbsolutePath_InstallationPathIsExactlyInstallPathParameter()
{
var configuration = new DeploydConfiguration();
var instance = new InstanceConfiguration()
{
AppName = "SomeApplication", InstallPath = @"c:\installfolder"
};
var fileSystem = new MockFileSystem();
var installationRoot = new InstallationRoot(configuration, instance, fileSystem);
Assert.That(installationRoot.Path, Is.EqualTo(@"c:\installfolder"));
}
private void NewInstanceButton_Click(object sender, EventArgs e)
{
ServerConfiguration instance = EditInstanceForm.ExecuteAdd();
InstanceConfiguration configuration = InstanceManager.LoadConfiguration();
configuration.Instances.Add(instance);
InstanceManager.SaveConfiguration(configuration);
_localInstancesEnumerated = false;
LoadInstances(configuration);
_cbInProcessInstanceName.Text = instance.Name;
}
public string CreateInstance(string packageName, InstanceConfiguration configuration)
{
using (var requestChain = new RequestChain(this))
{
var packet = new Packet(Header.New, requestChain.Id);
packet.Write(packageName);
configuration.Serialize(packet);
Send(packet);
requestChain.WaitForResult(5000);
return(requestChain.ResultBuffer.ReadString()); // instanceId
}
}
public OutputSelectionControl(InstanceConfiguration instConfig, InputConfiguration inConfig, IList <InstanceConfiguration> instances)
{
InitializeComponent();
Config = inConfig;
Instances = instances;
TextBlockPortDataType.Text = InputPortDataType(instConfig, inConfig);
var selections = LegalSelections(instConfig, inConfig, instances);
ListBoxOutputs.ItemsSource = selections;
ListBoxOutputs.SelectedItem = selections.SingleOrDefault(sel => inConfig.Remote == sel.Instance.Guid && inConfig.Output.PropertyName == sel.Port.Name);
}
private void GetBindings(BaseVariableState source, InstanceConfiguration dataSourceConfiguration)
{
foreach (DataSourceConfiguration item in dataSourceConfiguration.DataSources)
{
TraceEvent.Tracer.TraceVerbose(49, this.GetType().Name + ".GetBindings", String.Format("Item name: {0}, source: {1}",
item.Name, item.SelectedSource));
BuiltInType nt = TypeInfo.GetBuiltInType(source.DataType);
switch (item.SelectedSource)
{
case DataSourceConfiguration.Source.None:
DefaultSimulatorSourceConfiguration noneSC = item.SelectedSourceConfigurationBrowse as DefaultSimulatorSourceConfiguration;
if (noneSC.Selected && Settings.Default.AutoBindingToSimulatorForNotConfiguredVariables)
{
SimulatorInterface = Simulator.SimulatorDictionary.Find
(false, nt, noneSC.Name, new TimeSpan(0, 0, 0, 0, 500));
m_variable.AccessLevel = 1;
}
break;
case DataSourceConfiguration.Source.OPCClient:
OPCDAClientSourceConfiguration opcclientSC = item.SelectedSourceConfiguration as OPCDAClientSourceConfiguration;
if (opcclientSC.Selected)
{
OPCDAInterface = OPCDAClient.Client.Find(opcclientSC.ServerName, opcclientSC.SubscriptionName, opcclientSC.ItemName);
}
break;
case DataSourceConfiguration.Source.CommServer:
CommServerSourceConfiguration commSvrSC = item.SelectedSourceConfiguration as CommServerSourceConfiguration;
if (commSvrSC.Selected && !String.IsNullOrEmpty(commSvrSC.ItemName))
{
CommServerInterface = CAS.Lib.DeviceSimulator.Device.Find(commSvrSC.ItemName);
}
break;
case DataSourceConfiguration.Source.Simulator:
SimulatorSourceConfiguration simulatorSC = item.SelectedSourceConfiguration as SimulatorSourceConfiguration;
if (simulatorSC.Selected)
{
SimulatorInterface = Simulator.SimulatorDictionary.Find
(true, nt, simulatorSC.Tag.ToString(), new TimeSpan(0, 0, 0, 0, 500));
}
break;
default:
break;
}
}
}
public void WhenInstallRootIsConfigured_InstallationPathIsInstallRootPlusApplicationName()
{
var configuration = new DeploydConfiguration()
{
InstallRoot = @"c:\"
};
var instance = new InstanceConfiguration()
{
AppName = "SomeApplication"
};
var fileSystem = new MockFileSystem();
var installationRoot = new InstallationRoot(configuration, instance, fileSystem);
Assert.That(installationRoot.Path, Is.EqualTo(@"c:\SomeApplication"));
}
public void WhenInstallPathIsParameterisedRelativePath_InstallationPathIsRelativeToConfiguredPath()
{
var configuration = new DeploydConfiguration()
{
InstallRoot = @"c:\"
};
var instance = new InstanceConfiguration()
{
AppName = "SomeApplication", InstallPath = @"relativepath"
};
var fileSystem = new MockFileSystem();
var installationRoot = new InstallationRoot(configuration, instance, fileSystem);
Assert.That(installationRoot.Path, Is.EqualTo(@"c:\relativepath"));
}
protected Service(SubclassConfiguration.List subclasses, InstanceConfiguration.List instances)
: base(subclasses)
{
this.Instances = instances;
}
