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; }