public void Init(InitOptions options)
{
var resources = _webResourceRepo.GetAll(options.Prefixes.ToArray());
_logger.Info($"Serializing...");
var config = resources.Select(wr =>
{
var name = wr.GetAttributeValue <string>(WebResource.name);
var path = name.NormalizePath(options.WebResourcesRoot, wr.GetOptionSetValueAsEnum <WebResourceType>(WebResource.webresourcetype));
return(new WebResourceConfig
{
Name = name,
DisplayName = wr.GetAttributeValue <string>(WebResource.displayname) ?? name.GetDisplayName(),
Description = wr.GetAttributeValue <string>(WebResource.description) ?? string.Empty,
Path = path
});
});
var serialized = JsonConvert.SerializeObject(config, Formatting.Indented);
File.WriteAllText(options.ConfigFilePath, serialized);
_logger.Info("Done processing Web Resources.");
}
public static void InitNewConfig(InitOptions options)
{
if (File.Exists(PathUtils.ConfigPath))
{
Logger.Log(LogCategory.Warning, "This project already has a config file");
}
Logger.Log(LogCategory.Info, $"Writing new config file to {PathUtils.ConfigPath} ...");
var newConfigText = SerialiseConfig(ConfigDefaults.GetMinimalUserConfig());
try
{
using (var file = File.Open(PathUtils.ConfigPath, FileMode.CreateNew))
{
var writer = new StreamWriter(file);
writer.Write(newConfigText);
writer.Flush();
}
}
catch (Exception e)
{
throw new Exception("Failed to write new config file: " + e.Message, e);
}
var defaultConfigInstance = ConfigDefaults.GetDefaultConfig();
if (!Directory.Exists(defaultConfigInstance.Build.OutputDirectory))
{
Logger.Log(LogCategory.Info, $"Creating your build output folder at {defaultConfigInstance.Build.OutputDirectory} ...");
}
}
private void PrepareInitCommand()
{
cmd.Command("init", config =>
{
config.FullName = "Bake init build and deploy";
config.Description = "Initialize build and deploy template files in current directory";
var argSlnFilePath = config.Argument("[slnFile]", "Path to sln file, if empty sln will not be modified");
var overwrite = config.Option("-o|--overwrite", "Overwrite .cake files if they already exist", CommandOptionType.NoValue);
var buildSolution = config.Option("-bs|--buildSolution", "Build solution file, if not specified every project will be built separately", CommandOptionType.NoValue);
config.OnExecute(() =>
{
var solutionFilePath = argSlnFilePath.Value == null ? null : new DirectoryPath(Directory.GetCurrentDirectory()).CombineWithFilePath(argSlnFilePath.Value);
var initOptions = new InitOptions()
{
SolutionFilePath = solutionFilePath,
Overwrite = overwrite.HasValue(),
BuildSolution = buildSolution.HasValue()
};
commandRunner.InitCommand.Run(initOptions);
return(0);
});
config.HelpOption("-?|-h|--help");
});
}
static SkyDrive()
{
Office.Initialize = delegate(InitializationEnum initReason)
{
ViewManager.SwitchToView(ViewManager.SignIn);
InitOptions initOptions = new InitOptions();
initOptions.client_id = "000000004C100093";
initOptions.redirect_uri = "https://friendsinoffice.com/skydrive/App/callback.html";
initOptions.Scope = new string[] { "wl.skydrive_update", "wl.signin" };
initOptions.response_type = "code";
initOptions.logging = true;
LiveApi.Init(initOptions).Then(OnInitSuccess, OnFailure);
LiveApi.Event.subscribe("auth.login", OnLogon);
LiveApi.Event.subscribe("wl.log", OnLog);
LiveApi.GetLoginStatus().Then(OnLogon, OnFailure);
Element dropzone = Document.GetElementById("dropzone");
dropzone.AddEventListener("dragenter", NoOpHandler, false);
dropzone.AddEventListener("dragexit", NoOpHandler, false);
dropzone.AddEventListener("dragover", NoOpHandler, false);
dropzone.AddEventListener("drop", Drop, false);
BindingOptions bo = new BindingOptions();
bo.ID = TableBinding;
bo.Columns = new string[]{"ID"};
Office.Context.Document.Bindings.AddFromSelectionAsync(BindingType.Table, bo, delegate(ASyncResult result)
{
Office.Select("bindings#"+TableBinding).AddHandlerAsync(EventType.BindingSelectionChanged, OnBindingSelectionChanged);
OnBindingSelectionChanged(null);
});
};
}
public void GlobalOptionsInitTest(string type)
{
string[] args = GetArgs("init", type);
InitOptions opt = TestParseArguments <InitOptions>(args);
CheckFields(opt);
}
public static int Execute(InitOptions opts)
{
var _defaultColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Starting up the receive listener...");
Console.ForegroundColor = _defaultColor;
// Start the receive script
ProcessStartInfo start = new ProcessStartInfo()
{
FileName = "python3",
UseShellExecute = false,
RedirectStandardOutput = false,
Arguments = "Scripts/receive.py"
};
using (Process process = Process.Start(start))
{
// Save process pid to external file for later kill
File.WriteAllTextAsync(".pid", process.Id.ToString()).Wait();
}
return(0);
}
public WSmoothPingPong(InitOptions initOptions, PingPongOptions options)
{
_initOptions = initOptions;
_options = options;
SmoothStart();
}
private static int HandleInit(InitOptions options)
{
VersionFile versionFile = new VersionFile();
versionFile.SetVersion(options.InitialVersion);
versionFile.SerializeToFile();
return(0);
}
public TraversalEngine(Context context, QueryType query, RayFormat rayFormat, TriFormat triFormat,
TraversalOutput outputs, InitOptions options)
{
mRayFormat = rayFormat;
mRaySize = rayFormat == RayFormat.OriginDirectionInterleaved ? 24 : 32;
CheckError(TraversalApi.rtuTraversalCreate(ref mTraversal, (RTUquerytype)query, (RTUrayformat)rayFormat,
(RTUtriformat)triFormat, (uint)outputs, (uint)options, context.InternalPtr));
}
static int Init(InitOptions options)
{
var updateChecker = CheckForUpdates();
var exitCode = InitCommand.Run(GetConfig(new Config.CLIInitCommandConfig(options)));
WriteUpdateNotification(updateChecker);
return(exitCode);
}
public void GetHtmlNoPaymentOptionsTest()
{
IOptions options = new InitOptions();
string result = options.GetOptionString();
Assert.IsNull(result);
}
/// <summary>
/// Method that handles "init" command.
/// </summary>
/// <param name="initOptions">Options passed to the command.</param>
internal static void HandleInit(InitOptions initOptions)
{
CommandHandlerHelper.TryExecute(initOptions, options =>
{
var logger = CommandHandlerHelper.CreateLogger(options.IsDebug);
var storageInitializer = FileFsStorageInitializerFactory.Create(options.Instance, logger);
storageInitializer.Initialize(options.Size, options.FileNameLength);
});
}
public ZitiIdentity(InitOptions opts)
{
this.InitOpts = opts;
if (opts.IdentityFile != null)
{
string json = File.ReadAllText(opts.IdentityFile);
nid = JsonSerializer.Deserialize <Native.IdentityFile>(json);
}
}
public void RunActionTest()
{
var opt = new InitOptions();
var act = new ActionInit();
int status = act.Run(opt);
int lastRunStatus = act.GetLastRunStatus();
Assert.AreEqual(status, lastRunStatus, "Status need to be the same!!!");
}
public TemplatePlanResult Generate(InitOptions initOptions)
{
var filePaths = new List <string>()
{
"deploy\\deploy.ps1", "deploy\\deploy.cake"
};
// TODO
return(null);
}
public void GetHtmlNoApiKeyTest()
{
IOptions options = new InitOptions
{
PaymentRequest = new PaymentRequestOptions()
};
string result = options.GetOptionString();
Assert.IsNull(result);
}
private static int Init(InitOptions opts)
{
if (!Directory.Exists(opts.Directory))
{
Directory.CreateDirectory(opts.Directory);
}
var file = AdrFile.Save(new AdrDirectory(opts.Directory), AdrEntry.CreateInitial());
Console.WriteLine("Initialized and created {0}", file.FilePath);
return(0);
}
public InitHostedService(
IEngineConfigurationBuilder configurationBuilder,
InitOptions initOptions,
ILogger <InitHostedService> logger,
ITelemetryLogger telemetryLogger,
IHostApplicationLifetime appLifetime)
{
_configurationBuilder = configurationBuilder;
_initOptions = initOptions;
_logger = logger;
_telemetryLogger = telemetryLogger;
_appLifetime = appLifetime;
}
public IInitContext AcquireInitContext(InitOptions initOptions)
{
if (this.contexts == null)
{
this.contexts = new Stack <InitialisationContext>();
}
var context = new InitialisationContext(this, initOptions);
this.contexts.Push(context);
return(context);
}
/// <summary>
/// Runs the init action.
/// </summary>
/// <param name="options">CLI options for the init action.</param>
/// <param name="fromMain">Wheter or not this is called from the main method.</param>
/// <returns>CLI return code.</returns>
private static int Init(InitOptions options, bool fromMain = true)
{
InitAction initializer = new InitAction(options);
int result = initializer.Run();
#if DEBUG
if (fromMain == true)
{
Console.Read();
}
#endif
return(result);
}
private void InitDeployment(InitOptions opts)
{
ParseYamlFile(opts);
foreach (var service in _services)
{
_deployment.Name = service.Name;
_deployment.NameSpace = _nameSpace;
_deployment.ProjectDir = GetProjectName(service.Project);
_deployment.KubeDir = opts.KubeDirName;
_deployment.InitDeployment();
ConsoleMessage($"Deployment namespace and configmap for {service.Name.Trim()} has been created");
}
}
private SolutionInfo PrepareSolutionInfo(InitOptions initOptions)
{
if (initOptions.SolutionFilePath == null)
{
var currentDir = new DirectoryPath(Directory.GetCurrentDirectory());
Log.Header("Exploring projects - searching directory {CurrentDir}.", currentDir.FullPath);
Log.IncreaseIndent();
return(new SolutionInfo(solutionPath: currentDir, buildSolution: false));
}
var relativeSlnDir = new DirectoryPath(Directory.GetCurrentDirectory()).GetRelativePath(initOptions.SolutionFilePath);
Log.Header("Exploring projects - parsing solution file {SlnFile}.", relativeSlnDir.FullPath);
return(new SolutionInfo(initOptions.SolutionFilePath, initOptions.BuildSolution));
}
private static object RunInitAndReturnExitCode(InitOptions opts)
{
Telemetry.Current.TrackEvent("InitCommand");
if (!File.Exists("vstsbulkeditor.json"))
{
string json = JsonConvert.SerializeObject(EngineConfiguration.GetDefault(),
new FieldMapConfigJsonConverter(),
new ProcessorConfigJsonConverter());
StreamWriter sw = new StreamWriter("vstsbulkeditor.json");
sw.WriteLine(json);
sw.Close();
Trace.WriteLine("New vstsbulkeditor.json file has been created", "vstsbulkeditor");
}
return(0);
}
public InitHostedService(
IEngineConfigurationBuilder configurationBuilder,
ISettingsWriter settingsWriter,
IOptions <InitOptions> initOptions,
ILogger <InitHostedService> logger,
ITelemetryLogger telemetryLogger,
IHostApplicationLifetime appLifetime)
{
_configurationBuilder = configurationBuilder;
_settingWriter = settingsWriter;
_initOptions = initOptions.Value;
_logger = logger;
_telemetryLogger = telemetryLogger;
_appLifetime = appLifetime;
}
public void Run(InitOptions initOptions)
{
var solutionFilePath = initOptions.SolutionFilePath;
var buildResult = commandRunner.GenerateBuildScriptsCommand.Generate(initOptions);
var deployResult = commandRunner.GenerateDeployScriptsCommand.Generate(initOptions);
if (solutionFilePath != null && buildResult.GetAddedFiles().Any())
{
var relativePaths = buildResult.GetAddedFiles()
.Select(path => solutionFilePath.GetRelativePath(path).FullPath.Replace('/', '\\'))
.ToList();
commandRunner.UpdateVisualStudioSlnCommand.AddSolutionFolderToSlnFile(solutionFilePath.FullPath, "Build", "Build", relativePaths);
//commandRunner.UpdateVisualStudioSlnCommand.AddSolutionFolderToSlnFile(slnFilePath, "Deploy", "Deploy", deployScriptPaths);
}
}
/*
* int Main(string[] args)
* {
* return CommandLine.Parser.Default.ParseArguments<AddOptions, CommitOptions, CloneOptions>(args)
* .MapResult(
* (AddOptions opts) => RunAddAndReturnExitCode(opts),
* (CommitOptions opts) => RunCommitAndReturnExitCode(opts),
* (CloneOptions opts) => RunCloneAndReturnExitCode(opts),
* errs => 1);
* }*/
private static void Initialize(InitOptions opts)
{
try
{
ICoreSrcDependencies srcdep = FSCoreSrcDependencies.InitializeNew(opts.BSName, cwd, new DiskFSInterop(), opts.Cache);
if (opts.Cache != null)
{
var cachedep = CoreDstDependencies.InitializeNew(opts.BSName, true, DiskDstFSInterop.InitializeNew(opts.Cache), false);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
private static (InitOptions init, ExecuteOptions execute) ParseOptions(string[] args)
{
InitOptions initOptions = null;
ExecuteOptions executeOptions = null;
Parser.Default.ParseArguments <InitOptions, ExecuteOptions>(args)
.WithParsed <InitOptions>(opts =>
{
initOptions = opts;
})
.WithParsed <ExecuteOptions>(opts =>
{
executeOptions = opts;
});
return(initOptions, executeOptions);
}
/// <summary>
/// Initializes ROS
/// </summary>
/// <param name="args"> argv - parsed for remapping args (AND PARAMS??) </param>
/// <param name="name"> the node's name </param>
/// <param name="options"> options? </param>
public static void Init(string[] args, string name, InitOptions options)
{
// ROS_MASTER_URI/ROS_HOSTNAME definition precedence:
// 1. explicitely set by program
// 2. passed in as remap argument
// 3. environment variable
if (RemappingHelper.GetRemappings(ref args, out IDictionary <string, string> remapping))
{
Init(remapping, name, options);
}
else
{
throw new InvalidOperationException("Could not initialize ROS");
}
}
protected static object RunInitAndReturnExitCode(InitOptions opts, TelemetryClient telemetryClient)
{
_TelemetryClient.TrackEvent("InitCommand");
string configFile = opts.ConfigFile;
if (string.IsNullOrEmpty(configFile))
{
configFile = "configuration.json";
}
Log.Information("ConfigFile: {configFile}", configFile);
if (File.Exists(configFile))
{
Log.Information("Deleting old configuration.json reference file");
File.Delete(configFile);
}
if (!File.Exists(configFile))
{
Log.Information("Populating config with {Options}", opts.Options.ToString());
IEngineConfigurationBuilder cbuilder = new EngineConfigurationBuilder();
EngineConfiguration config;
switch (opts.Options)
{
case OptionsMode.Full:
config = cbuilder.BuildDefault();
break;
case OptionsMode.WorkItemTracking:
config = cbuilder.BuildWorkItemMigration();
break;
default:
config = cbuilder.BuildDefault();
break;
}
string json = JsonConvert.SerializeObject(config, Formatting.Indented,
new FieldMapConfigJsonConverter(),
new ProcessorConfigJsonConverter());
StreamWriter sw = new StreamWriter(configFile);
sw.WriteLine(json);
sw.Close();
Log.Information("New configuration.json file has been created");
}
return(0);
}
public void GetHtmlWithOptionsTest()
{
IOptions options = new InitOptions
{
PaymentRequest = new PaymentRequestOptions(),
ApiKey = "apiKey",
Settings = new SettingOptions()
};
string result = options.GetOptionString();
Assert.IsNotNull(result);
Assert.IsTrue(result.Contains("V.init({"));
Assert.IsTrue(result.Contains("\"paymentRequest\":{"));
Assert.IsTrue(result.Contains("\"apikey\":\"apiKey\""));
Assert.IsTrue(result.Contains("\"settings\":{"));
}
private static object RunInitAndReturnExitCode(InitOptions opts)
{
Telemetry.Current.TrackEvent("InitCommand");
string configFile = opts.ConfigFile;
if (configFile.IsEmpty())
{
configFile = "configuration.json";
}
Telemetry.Current.TrackEvent("InitCommand");
Trace.WriteLine(String.Format("ConfigFile: {0}", configFile), "[Info]");
if (File.Exists(configFile))
{
Trace.WriteLine("Deleting old configuration.json reference file", "[Info]");
File.Delete(configFile);
}
if (!File.Exists(configFile))
{
Trace.WriteLine(string.Format("Populating config with {0}", opts.Options.ToString()), "[Info]");
EngineConfiguration config;
switch (opts.Options)
{
case OptionsMode.Full:
config = EngineConfiguration.GetDefault();
break;
case OptionsMode.WorkItemTracking:
config = EngineConfiguration.GetWorkItemMigration();
break;
default:
config = EngineConfiguration.GetDefault();
break;
}
string json = JsonConvert.SerializeObject(config, Formatting.Indented,
new FieldMapConfigJsonConverter(),
new ProcessorConfigJsonConverter());
StreamWriter sw = new StreamWriter(configFile);
sw.WriteLine(json);
sw.Close();
Trace.WriteLine("New configuration.json file has been created", "[Info]");
}
return(0);
}
// Use this for initialization
public void create()
{
this.allArrivable = false;
this.initOptions = new InitOptions(11, 55, 25, 60, 36);
this.initOptions.initField();
this.initOptions.addWallField();
this.control = new ControlOperations(this.initOptions.getWall(), this.initOptions.getField());
this.control.check();
do
{
this.control.finalise();
this.allArrivable = this.control.checkArrivable();
}while(this.allArrivable == false);
this.spanpoints = new SettingSpanpoints();
this.spanpoints.Start();
}
