// Mode engages
public override void OnEngage()
{
base.OnEngage();
General.Interface.AddButton(BuilderPlug.Me.MenusForm.ColorConfiguration);
panel = new SoundEnvironmentPanel();
panel.OnShowWarningsOnlyChanged += PanelOnOnShowWarningsOnlyChanged;
docker = new Docker("soundenvironments", "Sound Environments", panel);
General.Interface.AddDocker(docker, true);
General.Interface.SelectDocker(docker);
worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.WorkerSupportsCancellation = true;
worker.DoWork += BuilderPlug.Me.UpdateSoundEnvironments;
worker.ProgressChanged += worker_ProgressChanged;
worker.RunWorkerCompleted += worker_RunWorkerCompleted;
UpdateData();
CustomPresentation presentation = new CustomPresentation();
presentation.AddLayer(new PresentLayer(RendererLayer.Background, BlendingMode.Mask, General.Settings.BackgroundAlpha));
presentation.AddLayer(new PresentLayer(RendererLayer.Grid, BlendingMode.Mask));
presentation.AddLayer(new PresentLayer(RendererLayer.Overlay, BlendingMode.Alpha, 1f, true));
presentation.AddLayer(new PresentLayer(RendererLayer.Things, BlendingMode.Alpha, 1.0f));
presentation.AddLayer(new PresentLayer(RendererLayer.Geometry, BlendingMode.Alpha, 1f, true));
renderer.SetPresentation(presentation);
}
// When plugin is initialized
public override void OnInitialize()
{
// Setup
me = this;
// Settings
showvisualthings = 2;
usegravity = false;
usehighlight = true;
LoadSettings();
// Load menus form and register it
menusform = new MenusForm();
menusform.Register();
// Load curve linedefs form
curvelinedefsform = new CurveLinedefsForm();
// Load find/replace form
findreplaceform = new FindReplaceForm();
// Load error checking form
errorcheckform = new ErrorCheckForm();
// villsa
sectorlights = new Lights[5];
// Load Undo\Redo docker
undoredopanel = new UndoRedoPanel();
undoredodocker = new Docker("undoredo", "Undo / Redo", undoredopanel);
General.Interface.AddDocker(undoredodocker);
}
public static void Main(string[] args)
{
/*
################################################################################################
## PARA GERAR/RODAR IMAGEM
## docker build -t sqlimagefromdockerfile .
## docker run -p 1433:1433 --name SQLfromDockerFile -d sqlimagefromdockerfile
##
## PARA SALVAR/CARREGAR IMAGEM:
## docker save -o sqlimagefromdockerfile.tar sqlimagefromdockerfile
## docker load -i sqlimagefromdockerfile.tar
##
##PARA REMOVER CONTEINER/IMAGEM:
## docker stop SQLfromDockerFile
## docker rm SQLfromDockerFile
## docker image rm sqlimagefromdockerfile
################################################################################################
*/
var docker = new Docker(@"C:\test_docker", new ConsoleNotifier());
//docker build -t sqlimagefromdockerfile .
docker.BuildAnImage("sqlimage", "./", "sqlimage.dockerfile");
// run -p 1433:1433 --name SQLfromDockerFile -d sqlimagefromdockerfile
docker.RunConteiner("sqlConteiner", "sqlimage", 1433, 1433);
var manager = new ContainerManager();
manager.Execute();
}
public void CanInspectContainer()
{
Docker.ProcessStatus process_status;
string process_output, process_error;
Docker.GetContainer("48743124ffee", out process_status, out process_output, out process_error);
}
public void CanExecCommand()
{
Docker.ProcessStatus process_status;
string process_output, process_error;
Docker.ExecuteInContainer("5a9d667f7a13", @"dpkg-query -W -f ${Package}'${Version}\n", out process_status, out process_output, out process_error);
}
public void PrivateNavigateTo()
{
this.Driver.Navigate().GoToUrl("https://docs.microsoft.com/en-us/dotnet/csharp/");
DotNetCoreGuide.Click();
Docker.Click();
Introduction.Click();
}
// When plugin is initialized
public override void OnInitialize()
{
// Setup
me = this;
// Settings
showvisualthings = 2;
usegravity = false;
LoadSettings();
LoadUISettings(); //mxd
// Load menus form and register it
menusform = new MenusForm();
menusform.Register();
menusform.TextureOffsetLock.Checked = lockSectorTextureOffsetsWhileDragging; //mxd
menusform.SyncronizeThingEditButton.Checked = syncthingedit; //mxd
menusform.SyncronizeThingEditSectorsItem.Checked = syncthingedit; //mxd
menusform.SyncronizeThingEditLinedefsItem.Checked = syncthingedit; //mxd
menusform.ItemLightRadii.Checked = showlightradii;
menusform.ButtonLightRadii.Checked = showlightradii;
menusform.ItemSoundRadii.Checked = showsoundradii;
menusform.ButtonSoundRadii.Checked = showsoundradii;
// Load Undo\Redo docker
undoredopanel = new UndoRedoPanel();
undoredodocker = new Docker("undoredo", "Undo / Redo", undoredopanel);
General.Interface.AddDocker(undoredodocker);
//mxd. Create Overrides docker
drawingOverridesPanel = new SectorDrawingOptionsPanel();
drawingOverridesDocker = new Docker("drawingoverrides", "Draw Settings", drawingOverridesPanel);
//mxd
General.Actions.BindMethods(this);
}
public Task <bool> Stop()
{
Docker.Remove(_dockerContainer.Name);
Docker.Remove(_watchContainer.Name);
return(Task.FromResult(true));
}
protected override void AddInterface()
{
// Add docker
docker = new Docker("drawgrid", "Draw Grid", panel);
General.Interface.AddDocker(docker, true);
General.Interface.SelectDocker(docker);
}
public async Task <bool> Logs()
{
var result = await Docker.Logs(_dockerContainer.Name);
Console.WriteLine(result);
return(true);
}
public void PartOne()
{
var input = Helpers.FileHelper.ParseFile(InputFile);
var docker = new Docker(input);
var val = docker.Initialize();
Assert.IsTrue(val == 9879607673316);
}
public SolutionComponent(FileInfo path, ProjectSettings settings)
{
_path = path;
_dockerContainer = Docker
.ContainerFromImage("mcr.microsoft.com/dotnet/sdk:5.0", $"{settings.GetProjectName()}-dotnet-{Name}")
.EntryPoint("dotnet")
.WithVolume(path.Directory.FullName, "/usr/local/src", true);
}
public void PartTwo()
{
var input = Helpers.FileHelper.ParseFile(InputFile);
var docker = new Docker(input);
var val = docker.Initialize(v2: true);
Assert.IsTrue(val == 3435342392262);
}
public void Test_KnownMask()
{
var input = Helpers.FileHelper.ParseFile(TestFile);
var docker = new Docker(input);
var val = docker.Initialize();
Assert.IsTrue(val == 165);
}
public void Test_KnownAddresses()
{
var input = Helpers.FileHelper.ParseFile(TestHelper.GetTestFile(this, "Test2"));
var docker = new Docker(input);
var val = docker.Initialize(v2: true);
Assert.IsTrue(val == 208);
}
// This is called after a map has been successfully opened
public override void OnMapOpenEnd()
{
if (tagExplorer == null)
{
tagExplorer = new TagExplorer();
docker = new Docker("tagexplorerdockerpanel", "Tag Explorer", tagExplorer);
General.Interface.AddDocker(docker);
tagExplorer.Setup();
}
}
private static Docker.Container CreateBaseContainer(
FileSystemInfo path,
ProjectSettings settings,
string name)
{
return(Docker
.ContainerFromImage("node", ClientComponent.ClientConfiguration.GetContainerName(settings, name))
.EntryPoint("yarn")
.WithVolume(Path.Combine(path.FullName, "src"), "/usr/local/src", true));
}
public async Task <IActionResult> PostAsync([FromBody] AILabelingInfo info)
{
string tempPath, tempDir;
tempPath = Path.GetTempPath();
// Remove Base64 header that might be added by the fronted creating the Base64 code
info.data.ForEach((x) => x.Base64 = x.Base64.Replace("data:image/png;base64,", ""));
tempDir = PathHelper.GetRandomFileNameSecure(tempPath);
var(inDir, outDir) = CreateFolders(tempDir);
info.data.ForEach((x) =>
{
var bytes = x.Base64.Base64ToByte();
System.IO.File.WriteAllBytes(Path.Combine(inDir, x.Name), bytes);
});
// Combine options
List <string> options;
options = new List <string>();
options.Add("--rm");
options.Add(info.config.Options);
options.Add($"-v {inDir}:{info.config.InputDirectory}");
options.Add($"-v {outDir}:{info.config.OutputDirectory}");
var optionsString = string.Join(" ", options.ToArray());
var res = await Docker.RunAsync(info.config.DockerImageName, optionsString, info.config.Parameter);
IActionResult actionResult;
try
{
var filePaths = Directory.GetFiles(outDir);
var projectId = info.data.First().ProjectId;
var files = filePaths.Select(path => EncodeImage(projectId, path));
actionResult = Ok(await Task.WhenAll(files));
}
catch (Exception e)
{
actionResult = BadRequest(e.Message);
}
// Delete temporaryDirectory and return
Directory.Delete(tempDir, true);
return(actionResult);
}
public Task <bool> Stop()
{
Docker.Remove(_dockerContainer.Name);
if (_tempPath.Exists)
{
_tempPath.Delete(true);
}
return(Task.FromResult(true));
}
public async Task InitializeAsync()
{
if (Docker.Exists(DockerResource.Container, DefaultRyukContainerName))
{
var resourceReaper = await ResourceReaper.GetAndStartDefaultAsync()
.ConfigureAwait(false);
await resourceReaper.DisposeAsync()
.ConfigureAwait(false);
}
}
public IActionResult Index()
{
EnvironmentalVariablesController.Sender = "Docker";
ResourceController.Sender = "Docker";
var d = DataProvider.GetDockersByUserId(UserController.LoginUser.ID).Result;
tmpDockers = d;
tmpDockers.ForEach(a => a.SetVariables());
SelectedDocker = new Docker();
return(View(d));
}
// This is called after a map has been closed
public override void OnMapCloseBegin()
{
// If we have a Tag Explorer panel, remove it
if (tagExplorer != null)
{
tagExplorer.Terminate();
General.Interface.RemoveDocker(docker);
docker = null;
tagExplorer.Dispose();
tagExplorer = null;
}
}
public ContainerListResponse(Docker.DotNet.Models.ContainerListResponse fromDockerLib)
{
this.Id = fromDockerLib.Id;
this.Names = fromDockerLib.Names;
this.Image = fromDockerLib.Image;
this.Created = fromDockerLib.Created;
this.Command = fromDockerLib.Command;
this.Status = fromDockerLib.Status;
this.SizeRw = fromDockerLib.SizeRw;
this.SizeRootFs = fromDockerLib.SizeRootFs;
this.Ports = fromDockerLib.Ports;
}
public static async Task Load(string tag)
{
var image = new ImageInfo();
image.Tag = tag;
Docker.PullImage(image.Tag);
var(code, timeStamp) = Docker.GetTimestampForImage(image.Tag);
image.TimeStamp = timeStamp;
var result = await Anchore.RegisterImage(image);
WriteLine($"Added: {image.Tag}; Analyzed: {result}");
}
public IActionResult Edit(string id)
{
if (id != null)
{
var selectedDocker = DB.Find <Docker>().OneAsync(id).Result;
selectedDocker.SetVariables();
SelectedDocker = selectedDocker;
}
SelectedDocker.SetVariables();
return(View(SelectedDocker));
}
// Occurs before the map is closed
public override void OnMapCloseBegin()
{
// If we have a Comments panel, remove it
if (dockerpanel != null)
{
dockerpanel.Terminate();
General.Interface.RemoveDocker(commentsdocker);
commentsdocker = null;
dockerpanel.Dispose();
dockerpanel = null;
}
}
// This is called after a map has been successfully opened
public override void OnMapOpenEnd()
{
// If we just opened a UDMF format map, we want to create the Comments panel!
if (General.Map.Config.FormatInterface == "UniversalMapSetIO")
{
dockerpanel = new CommentsDocker();
commentsdocker = new Docker("commentsdockerpanel", "Comments", dockerpanel);
General.Interface.AddDocker(commentsdocker);
dockerpanel.Setup();
dockerpanel.UpdateListSoon();
}
}
public override EStateNode Tick(SubStarBody body)
{
for (int i = body.hub.dock.dockedShips.Count - 1; i >= 0; i--)
{
if (body.hub.dock.dockedShips[i].state != EShipState.docked)
{
continue;
}
Docker.ToUndock(body.hub.dock.dockedShips[i]);
}
return(EStateNode.SUCCESS);
}
public override void Execute(ListOptions options, ILogger logger)
{
var stacks = AppDirectory.GetStacks().OrderBy(s => s).ToArray();
var runningStacks = Docker.GetComposeStacks().ToArray();
foreach (var stack in stacks)
{
var color = runningStacks.Contains(stack) ? Color.Success : Color.Danger;
Output.Fancy.WriteLine(stack, color);
}
logger.Info("stack list", new { stack_count = stacks.Length, stacks = string.Join(",", stacks), running_stacks = string.Join(",", runningStacks) });
}
private static void CheckDocker(ILogger logger, IVerb verb, UserConfig config)
{
PerformanceTesting.Checkpoint("Begin Docker Check");
logger.Trace("checking docker");
if (verb.RequiresDocker && config.Checks.Docker && !Docker.IsRunning())
{
logger.Fatal("docker check failed");
throw new FatalException("Docker daemon is unreachable or not running.");
}
PerformanceTesting.Checkpoint("End Docker Check");
}
public override void Execute(DownOptions options, ILogger logger)
{
var stacks = options.Stacks.Any() ? options.Stacks : Docker.GetComposeStacks();
if (!stacks.Any())
{
logger.Error("no running stacks found");
ErrorPrinter.Error("There are no running stacks.");
return;
}
logger.Trace("stopping stacks in parallel", new { stack_count = stacks.Count(), stacks = string.Join(",", stacks) });
new ParallelTaskManager <string, TaskState>(stacks, GetRow, (stack, progress) => Execute(stack, progress, options, logger), HandleProgress, new[] { 0, 5 })
.Execute(Settings.UserConfig.Parallelism);
}
public void Ctor()
{
var docker = new Docker();
}
private void AddDocker()
{
portalexplorer = new PortalExplorer();
// panel.OnShowWarningsOnlyChanged += PanelOnOnShowWarningsOnlyChanged;
docker = new Docker("portalexplorer", "Portal Explorer", portalexplorer);
General.Interface.AddDocker(docker, true);
}
