public void Test_RubyHash()
{
bool test = true;
try
{
Dictionary <string, object> ctorTestO = new Dictionary <string, object>();
ctorTestO.Add("testkey", new List <int>()
{
1, 2, 3, 4
});
Dictionary <string, string> ctorTest = new Dictionary <string, string>();
ctorTest.Add("test", "testValue");
RubyHash hash = new RubyHash(ctorTestO);
RubyHash hash2 = new RubyHash(ctorTest);
RubyHash mergedHash = hash.Merge(hash2);
mergedHash = hash.Merge(ctorTest);
mergedHash = hash2.Merge(ctorTestO);
}
catch
{
test = false;
}
Assert.AreEqual(true, test);
}
public static RubyHash GetSSHDUsers(string cygwinPath)
{
string passwdFile = Path.Combine(cygwinPath, "etc", "passwd");
RubyHash users = new RubyHash();
foreach (string line in File.ReadAllLines(passwdFile))
{
string[] userInfo = line.Split(':');
if (userInfo.Length == 7)
{
string user = userInfo[0];
string windowsUserSID = userInfo[4].Split(',')[1];
users[user] = new RubyHash() {
{"user", userInfo[0]},
{"uid", userInfo[2]},
{"gid", userInfo[3]},
{"sid", windowsUserSID},
{"home", userInfo[5]},
{"shell", userInfo[6]}
};
}
}
return users;
}
public void PostReceive(RubyHash options)
{
Logger.Debug("Running post receive for gear {0}", this.Uuid);
Dictionary <string, string> gearEnv = Environ.ForGear(this.ContainerDir);
string repoDir = Path.Combine(this.ContainerDir, "app-root", "runtime", "repo");
Directory.CreateDirectory(repoDir);
ApplicationRepository applicationRepository = new ApplicationRepository(this);
applicationRepository.Archive(repoDir, options["ref"]);
options["deployment_datetime"] = this.LatestDeploymentDateTime();
Build(options);
Logger.Debug("Running post receive - prepare for gear {0}", this.Uuid);
Prepare(options);
Logger.Debug("Running post receive - distribute for gear {0}", this.Uuid);
Distribute(options);
Logger.Debug("Running post receive - activate for gear {0}", this.Uuid);
Activate(options);
}
public static RubyHash GetOpenshiftFacts()
{
RubyHash nodeUtilization = Node.NodeUtilization();
return(new RubyHash()
{
{ "district_uuid", DistrictConfig.Exists() ? DistrictConfig.Values["uuid"] : "NONE" },
{ "district_active", DistrictConfig.Exists() ? (DistrictConfig.Values["active"] == "true") : false },
{ "district_first_uid", DistrictConfig.Exists() ? DistrictConfig.Values["first_uid"] : "1000" },
{ "district_max_uid", DistrictConfig.Exists() ? DistrictConfig.Values["max_uid"] : "6999" },
{ "public_ip", NodeConfig.Values["PUBLIC_IP"] },
{ "public_hostname", NodeConfig.Values["PUBLIC_HOSTNAME"] },
{ "node_profile", nodeUtilization["node_profile"] },
{ "max_active_gears", nodeUtilization["max_active_gears"] },
{ "no_overcommit_active", nodeUtilization["no_overcommit_active"] },
{ "quota_blocks", nodeUtilization["quota_blocks"] },
{ "quota_files", nodeUtilization["quota_files"] },
{ "gears_active_count", nodeUtilization["gears_active_count"] },
{ "gears_total_count", nodeUtilization["gears_total_count"] },
{ "gears_idle_count", nodeUtilization["gears_idled_count"] },
{ "gears_stopped_count", nodeUtilization["gears_stopped_count"] },
{ "gears_started_count", nodeUtilization["gears_started_count"] },
{ "gears_deploying_count", nodeUtilization["gears_deploying_count"] },
{ "gears_unknown_count", nodeUtilization["gears_unknown_count"] },
{ "gears_usage_pct", nodeUtilization["gears_usage_pct"] },
{ "gears_active_usage_pct", nodeUtilization["gears_active_usage_pct"] },
{ "git_repos", nodeUtilization["git_repos_count"] },
{ "capacity", nodeUtilization["capacity"] },
{ "active_capacity", nodeUtilization["active_capacity"] },
{ "sshfp", "" },
});
}
public static RubyHash GetSSHDUsers(string cygwinPath)
{
string passwdFile = Path.Combine(cygwinPath, "etc", "passwd");
RubyHash users = new RubyHash();
foreach (string line in File.ReadAllLines(passwdFile))
{
string[] userInfo = line.Split(':');
if (userInfo.Length == 7)
{
string user = userInfo[0];
string windowsUserSID = userInfo[4].Split(',')[1];
users[user] = new RubyHash()
{
{ "user", userInfo[0] },
{ "uid", userInfo[2] },
{ "gid", userInfo[3] },
{ "sid", windowsUserSID },
{ "home", userInfo[5] },
{ "shell", userInfo[6] }
};
}
}
return(users);
}
public ReturnStatus Execute()
{
ReturnStatus status = new ReturnStatus();
try
{
ApplicationContainer container = new ApplicationContainer(WithAppUuid, WithContainerUuid, null, WithAppName,
WithContainerName, WithNamespace, null, null, null, WithUid);
RubyHash options = new RubyHash();
options["all"] = All;
if (ParallelConcurrencyRatio != 0.0)
{
options["parallelConcurrencyRatio"] = ParallelConcurrencyRatio;
}
status.Output = container.Restart(CartName, options);
status.ExitCode = 0;
}
catch (Exception ex)
{
Logger.Error("Error running oo-restart command: {0} - {1}", ex.Message, ex.StackTrace);
status.Output = ex.ToString();
status.ExitCode = 1;
}
return(status);
}
public ReturnStatus Execute()
{
ReturnStatus status = new ReturnStatus();
try
{
ApplicationContainer container = new ApplicationContainer(WithAppUuid, WithContainerUuid, null, WithAppName,
WithContainerName, WithNamespace, null, null, null, WithUid);
RubyHash options = new RubyHash();
options["all"] = All;
if (ParallelConcurrencyRatio != 0.0)
{
options["parallelConcurrencyRatio"] = ParallelConcurrencyRatio;
}
status.Output = container.Restart(CartName, options);
status.ExitCode = 0;
}
catch (Exception ex)
{
Logger.Error("Error running oo-restart command: {0} - {1}", ex.Message, ex.StackTrace);
status.Output = ex.ToString();
status.ExitCode = 1;
}
return status;
}
private void _read()
{
_code = ((RubyMarshal.Codes)m_io.ReadU1());
switch (Code)
{
case RubyMarshal.Codes.PackedInt: {
_body = new PackedInt(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.Bignum: {
_body = new Bignum(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubyArray: {
_body = new RubyArray(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubySymbolLink: {
_body = new PackedInt(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubyStruct: {
_body = new RubyStruct(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubyString: {
_body = new RubyString(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.InstanceVar: {
_body = new InstanceVar(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubyHash: {
_body = new RubyHash(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubySymbol: {
_body = new RubySymbol(m_io, this, m_root);
break;
}
case RubyMarshal.Codes.RubyObjectLink: {
_body = new PackedInt(m_io, this, m_root);
break;
}
}
}
public List <RubyHash> WithGearRotation(RubyHash options, GearRotationCallback action)
{
dynamic localGearEnv = Environ.ForGear(this.ContainerDir);
Manifest proxyCart = this.Cartridge.WebProxy();
List <object> gears = new List <object>();
// TODO: vladi: verify if this is needed for scalable apps
//if (options.ContainsKey("all") && proxyCart != null)
//{
// if ((bool)options["all"])
// {
// gears = this.GearRegist.Entries["web"].Keys.ToList<object>();
// }
// else if (options.ContainsKey("gears"))
// {
// List<string> g = (List<string>)options["gears"];
// gears = this.GearRegist.Entries["web"].Keys.Where(e => g.Contains(e)).ToList<object>();
// }
// else
// {
// try
// {
// gears.Add(this.GearRegist.Entries["web"][this.Uuid]);
// }
// catch
// {
// gears.Add(this.Uuid);
// }
// }
//}
//else
{
gears.Add(this.Uuid);
}
double parallelConcurrentRatio = PARALLEL_CONCURRENCY_RATIO;
if (options.ContainsKey("parallel_concurrency_ratio"))
{
parallelConcurrentRatio = (double)options["parallel_concurrency_ratio"];
}
int batchSize = CalculateBatchSize(gears.Count, parallelConcurrentRatio);
int threads = Math.Max(batchSize, MAX_THREADS);
List <RubyHash> result = new List <RubyHash>();
// need to parallelize
foreach (var targetGear in gears)
{
result.Add(RotateAndYield(targetGear, localGearEnv, options, action));
}
return(result);
}
public void Test_PostReceive_Init()
{
ApplicationContainer container = TestHelper.CreateAppContainer();
RubyHash options = new RubyHash();
options["init"] = true;
options["all"] = true;
options["reportDeployment"] = true;
options["ref"] = "master";
container.PostReceive(options);
}
public List <RubyHash> Restart(string cartName, RubyHash options)
{
List <RubyHash> result = WithGearRotation(options,
(GearRotationCallback) delegate(object targetGear, Dictionary <string, string> localGearEnv, RubyHash opts)
{
return(RestartGear(targetGear, localGearEnv, cartName, opts));
});
return(result);
}
public void Test_PostReceive_Init()
{
ApplicationContainer container = TestHelper.CreateAppContainer();
RubyHash options = new RubyHash();
options["init"] = true;
options["all"] = true;
options["reportDeployment"] = true;
options["ref"] = "master";
container.PostReceive(options);
}
public void TestFacterOK()
{
// Arrange
// Act
RubyHash facts = Uhuru.Openshift.Runtime.Utils.Facter.GetFacterFacts();
// Assert
Assert.IsTrue(facts.ContainsKey("operatingsystem"));
Assert.AreEqual(facts["operatingsystem"], "windows");
}
private RubyHash ActivateRemoteGear(GearRegistry.Entry gear, Dictionary <string, string> gearEnv, RubyHash options)
{
string gearUuid = gear.Uuid;
RubyHash result = new RubyHash();
result["status"] = RESULT_FAILURE;
result["gear_uuid"] = this.Uuid;
result["deployment_id"] = options["deployment_id"];
result["messages"] = new List <string>();
result["errors"] = new List <string>();
string postInstallOptions = options["post_install"] == true ? "--post-install" : "";
result["messages"].Add(string.Format("Activating gear {0}, deployment id: {1}, {2}", gearUuid, options["deployment_id"], postInstallOptions));
try
{
string ooSSH = @"/cygpath/c/openshift/oo-bin/oo-ssh";
string bashBinary = Path.Combine(NodeConfig.Values["SSHD_BASE_DIR"], "bin\bash.exe");
string sshCommand = string.Format("{0} {1} gear activate {2} --as-json {3} --no-rotation",
ooSSH, gear.ToSshUrl(), options["deployment_id"], postInstallOptions);
string bashArgs = string.Format("--norc --login -c '{0}'", sshCommand);
string command = string.Format("{0} {1}", bashBinary, bashArgs);
string output = RunProcessInContainerContext(this.ContainerDir, command).StdOut;
if (string.IsNullOrEmpty(output))
{
throw new Exception("No result JSON was received from the remote activate call");
}
Dictionary <string, object> activateResult = JsonConvert.DeserializeObject <Dictionary <string, object> >(output);
if (!activateResult.ContainsKey("status"))
{
throw new Exception("Invalid result JSON received from remote activate call");
}
result["messages"].Add(activateResult["messages"]);
result["errors"].Add(activateResult["errors"]);
result["status"] = activateResult["status"];
}
catch (Exception e)
{
result["errors"].Add("Gear activation failed: " + e.ToString());
}
return(result);
}
public string Deploy(RubyHash options)
{
StringBuilder output = new StringBuilder();
if (!options.ContainsKey("artifact_url"))
{
output.AppendLine(PreReceive(options));
PostReceive(options);
}
else
{
output.AppendLine(DeployBinaryArtifact(options));
}
return(output.ToString());
}
public DeploymentMetadata(ApplicationContainer container, string deploymentDatetime)
{
this.file = Path.Combine(container.ContainerDir, "app-deployments", deploymentDatetime, "metadata.json");
if (File.Exists(file))
{
Load();
}
else
{
using (File.Create(this.file)) { };
container.SetRWPermissions(this.file);
this.metadata = this.defaults;
Save();
}
}
public static void RemoveKey(string targetDirectory, string user, string key)
{
RubyHash userInfo = CygwinPasswd.GetSSHDUser(targetDirectory, user);
string homeDir = LinuxFiles.Cygpath(userInfo["home"], true);
string authorizedKeysFile = Path.Combine(homeDir, ".ssh", "authorized_keys");
if (!File.Exists(authorizedKeysFile))
{
return;
}
List <string> content = File.ReadAllLines(authorizedKeysFile).ToList();
content.Remove(key);
File.WriteAllLines(authorizedKeysFile, content, Encoding.ASCII);
}
public static void AddKey(string targetDirectory, string user, string key)
{
RubyHash userInfo = CygwinPasswd.GetSSHDUser(targetDirectory, user);
string homeDir = LinuxFiles.Cygpath(userInfo["home"], true);
Directory.CreateDirectory(Path.Combine(homeDir, ".ssh"));
string authorizedKeysFile = Path.Combine(homeDir, ".ssh", "authorized_keys");
if (!File.Exists(authorizedKeysFile))
{
File.Create(authorizedKeysFile).Dispose();
}
Logger.Debug("Adding key to {0}", authorizedKeysFile);
File.AppendAllLines(authorizedKeysFile, new string[] { key }, Encoding.ASCII);
}
public void Test_ConnectionModel()
{
bool result = false;
RubyHash specs = new RubyHash();
specs["Components"] = new List<object>(){"TestComponent"};
Connection m = Connection.FromDescriptor("testConnection", specs);
if (m != null)
{
var desc = m.ToDescriptor();
if (desc != null)
{
result = true;
}
}
Assert.AreEqual(true, result);
}
public string Prepare(RubyHash options = null)
{
if (options == null)
{
options = new RubyHash();
}
StringBuilder output = new StringBuilder();
output.AppendLine("Preparing build for deployment");
if (!options.ContainsKey("deployment_datetime"))
{
throw new ArgumentException("deployment_datetime is required");
}
string deploymentDatetime = options["deployment_datetime"].ToString();
Dictionary <string, string> env = Environ.ForGear(this.ContainerDir);
// TODO clean runtime dirs, extract archive
this.Cartridge.DoActionHook("prepare", env, options);
string deploymentId = CalculateDeploymentId();
LinkDeploymentId(deploymentDatetime, deploymentId);
try
{
SyncRuntimeRepoDirToDeployment(deploymentDatetime);
SyncRuntimeDependenciesDirToDeployment(deploymentDatetime);
SyncRuntimeBuildDependenciesDirToDeployment(deploymentDatetime);
DeploymentMetadata deploymentMetadata = DeploymentMetadataFor(deploymentDatetime);
deploymentMetadata.Id = deploymentId;
deploymentMetadata.Checksum = CalculateDeploymentChecksum(deploymentId);
deploymentMetadata.Save();
options["deployment_id"] = deploymentId;
output.AppendLine("Deployment id is " + deploymentId);
}
catch (Exception e)
{
Logger.Error("Error preparing deployment. Options: {0} - {1} - {2}", JsonConvert.SerializeObject(options), e.Message, e.StackTrace);
output.AppendLine("Error preparing deployment " + deploymentId);
UnlinkDeploymentId(deploymentId);
}
return(output.ToString());
}
public RubyHash UpdateLocalProxyStatus(RubyHash args)
{
RubyHash result = new RubyHash();
object cartridge = args["cartridge"];
object action = args["action"];
object targetGear = args["target_gear"];
object persist = args["persist"];
try
{
string output = this.UpdateProxyStatusForGear(new RubyHash()
{
{ "cartridge", cartridge },
{ "action", action },
{ "gear_uuid", targetGear },
{ "persist", persist }
});
result = new RubyHash()
{
{ "status", RESULT_SUCCESS },
{ "proxy_gear_uuid", this.Uuid },
{ "target_gear_uuid", targetGear },
{ "messages", new List <string>() },
{ "errors", new List <string>() }
};
}
catch (Exception ex)
{
result = new RubyHash()
{
{ "status", RESULT_FAILURE },
{ "proxy_gear_uuid", this.Uuid },
{ "target_gear_uuid", targetGear },
{ "messages", new List <string>() },
{ "errors", new List <string>()
{
string.Format("An exception occured updating the proxy status: {0}\n{1}", ex.Message, ex.StackTrace)
} }
};
}
return(result);
}
public int Stop(bool force = false)
{
return(PRunner(gear =>
{
RubyHash options = new RubyHash()
{
{ "user_initiated", false },
};
if (force)
{
options["force"] = true;
options["term_delay"] = 10;
}
gear.StopGear(options);
}));
}
public int Stop(bool force = false)
{
return PRunner(gear =>
{
RubyHash options = new RubyHash()
{
{ "user_initiated", false },
};
if (force)
{
options["force"] = true;
options["term_delay"] = 10;
}
gear.StopGear(options);
});
}
public string UpdateProxyStatusForGear(RubyHash options)
{
string action = options["action"];
if (action != "enable" && action != "disable")
{
new ArgumentException("action must either be :enable or :disable");
}
string gearUuid = options["gear_uuid"];
if (gearUuid == null)
{
new ArgumentException("gear_uuid is required");
}
Manifest cartridge = options["cartridge"] ?? this.Cartridge.WebProxy();
if (cartridge == null)
{
throw new ArgumentNullException("Unable to update proxy status - no proxy cartridge found");
}
bool persist = options["persist"] != null && options["persist"] == true;
string control = string.Format("{0}-server", action);
List <string> args = new List <string>();
if (persist)
{
args.Add("persist");
}
args.Add(gearUuid);
return(this.Cartridge.DoControl(
control, cartridge, new Dictionary <string, object>()
{
{ "args", string.Join(" ", args) },
{ "pre_action_hooks_enabled", false },
{ "post_action_hooks_enabled", false }
}));
}
public RubyHash RestartGear(object targetGear, Dictionary <string, string> localGearEnv, string cartName, dynamic options)
{
string targetGearUuid = targetGear is string?(string)targetGear : ((GearRegistry.Entry)targetGear).Uuid;
RubyHash result = new RubyHash()
{
{ "status", RESULT_SUCCESS },
{ "messages", new List <string>() },
{ "errors", new List <string>() },
{ "target_gear_uuid", targetGearUuid }
};
try
{
if (targetGearUuid == this.Uuid)
{
result["messages"].Add(this.Cartridge.StartCartridge("restart", cartName, options));
}
else
{
string ooSSH = @"/cygpath/c/openshift/oo-bin/oo-ssh";
string bashBinary = Path.Combine(NodeConfig.Values["SSHD_BASE_DIR"], "bin\bash.exe");
if (targetGear is string)
{
targetGear = new GearRegistry.Entry(options);
}
string sshCommand = string.Format("{0} {1} gear restart --cart {2} --as-json",
ooSSH, ((GearRegistry.Entry)targetGear).ToSshUrl(), cartName);
string bashArgs = string.Format("--norc --login -c '{0}'", sshCommand);
string command = string.Format("{0} {1}", bashBinary, bashArgs);
RunProcessInContainerContext(this.ContainerDir, command);
}
}
catch (Exception ex)
{
result["errors"].Add(ex.ToString());
result["status"] = RESULT_FAILURE;
Logger.Error(ex.ToString());
}
return(result);
}
public static IEnumerable <ApplicationContainer> All(Hourglass hourglass = null, bool loadenv = true)
{
EtcUser[] users = new Etc(NodeConfig.Values).GetAllUsers();
foreach (EtcUser user in users)
{
if (user.Gecos.StartsWith("openshift_service"))
{
RubyHash env = new RubyHash();
string gearNamespace = null;
if (loadenv)
{
env = new RubyHash(Environ.Load(new string[] { Path.Combine(user.Dir, ".env") }));
}
if (env.ContainsKey("OPENSHIFT_GEAR_DNS"))
{
gearNamespace = env["OPENSHIFT_GEAR_DNS"];
}
ApplicationContainer app = null;
try
{
app = new ApplicationContainer(env["OPENSHIFT_APP_UUID"],
user.Name, user, env["OPENSHIFT_APP_NAME"], env["OPENSHIFT_GEAR_NAME"], gearNamespace, null, null, hourglass);
}
catch (Exception ex)
{
Logger.Error("Failed to instantiate ApplicationContainer for uid {0}/uuid {1}: {2}",
user.Uid, env["OPENSHIFT_APP_UUID"], ex.Message);
Logger.Error("Stacktrace: {0}", ex.StackTrace);
continue;
}
yield return(app);
}
}
}
public void Test_ConnectionModel()
{
bool result = false;
RubyHash specs = new RubyHash();
specs["Components"] = new List <object>()
{
"TestComponent"
};
Connection m = Connection.FromDescriptor("testConnection", specs);
if (m != null)
{
var desc = m.ToDescriptor();
if (desc != null)
{
result = true;
}
}
Assert.AreEqual(true, result);
}
protected override void ProcessRecord()
{
ReturnStatus status = new ReturnStatus();
ApplicationContainer container = new ApplicationContainer(WithAppUuid, WithContainerUuid, null, WithAppName,
WithContainerName, WithNamespace, null, null, null);
try
{
RubyHash options = new RubyHash();
options["deployment_id"] = DeploymentId;
status.Output = container.Activate(options);
status.ExitCode = 0;
}
catch (Exception ex)
{
Logger.Error("Error running oo-activate command: {0} - {1}", ex.Message, ex.StackTrace);
status.Output = ex.ToString();
status.ExitCode = 1;
}
this.WriteObject(status);
}
public void Test_RubyHash()
{
bool test = true;
try
{
Dictionary<string, object> ctorTestO = new Dictionary<string, object>();
ctorTestO.Add("testkey", new List<int>() { 1, 2, 3, 4 });
Dictionary<string, string> ctorTest = new Dictionary<string, string>();
ctorTest.Add("test", "testValue");
RubyHash hash = new RubyHash(ctorTestO);
RubyHash hash2 = new RubyHash(ctorTest);
RubyHash mergedHash = hash.Merge(hash2);
mergedHash = hash.Merge(ctorTest);
mergedHash = hash2.Merge(ctorTestO);
}
catch
{
test = false;
}
Assert.AreEqual(true, test);
}
public ReturnStatus Execute()
{
ReturnStatus status = new ReturnStatus();
try
{
ApplicationContainer container = new ApplicationContainer(WithAppUuid, WithContainerUuid, null, WithAppName,
WithContainerName, WithNamespace, null, null, null, WithUid);
RubyHash options = new RubyHash();
options["deployment_id"] = WithDeploymentId;
status.Output = container.Activate(options);
status.ExitCode = 0;
}
catch (Exception ex)
{
Logger.Error("Error running oo-activate command: {0} - {1}", ex.Message, ex.StackTrace);
status.Output = ex.ToString();
status.ExitCode = 1;
}
return status;
}
public ReturnStatus Execute()
{
ReturnStatus status = new ReturnStatus();
try
{
ApplicationContainer container = new ApplicationContainer(WithAppUuid, WithContainerUuid, null, WithAppName,
WithContainerName, WithNamespace, null, null, null);
RubyHash options = new RubyHash();
options["deployment_id"] = WithDeploymentId;
status.Output = container.Activate(options);
status.ExitCode = 0;
}
catch (Exception ex)
{
Logger.Error("Error running oo-activate command: {0} - {1}", ex.Message, ex.StackTrace);
status.Output = ex.ToString();
status.ExitCode = 1;
}
return(status);
}
public static void WriteFactsFile(string file)
{
try
{
RubyHash common = Facter.GetFacterFacts();
RubyHash nodeSpecific = Facter.GetOpenshiftFacts();
dynamic desc = common.Merge(nodeSpecific);
using (StringWriter sw = new StringWriter())
{
Serializer serializer = new Serializer();
serializer.Serialize(new Emitter(sw, 2, int.MaxValue, true), desc);
File.WriteAllText(file, sw.ToString());
}
}
catch (Exception ex)
{
Logger.Error("Error while generating facts file: {0} - {1}", ex.Message, ex.StackTrace);
throw;
}
}
protected override void ProcessRecord()
{
ReturnStatus status = new ReturnStatus();
ApplicationContainer container = new ApplicationContainer(WithAppUuid, WithContainerUuid, null, WithAppName,
WithContainerName, WithNamespace, null, null, null);
RubyHash options = new RubyHash();
options["all"] = All;
options["parallelConcurrencyRatio"] = ParallelConcurrencyRatio;
try
{
status.Output = container.Restart(CartName, options);
status.ExitCode = 0;
}
catch (Exception ex)
{
Logger.Error("Error running oo-restart command: {0} - {1}", ex.Message, ex.StackTrace);
status.Output = ex.ToString();
status.ExitCode = 1;
}
this.WriteObject(status);
}
public void CleanRuntimeDirs(RubyHash options)
{
List <string> dirs = new List <string>();
foreach (string dir in new string[] { "dependencies", "build_dependencies", "repo" })
{
if (options[dir] == true)
{
dirs.Add(dir);
}
}
if (dirs.Count == 0)
{
return;
}
foreach (string dir in dirs)
{
string directory = Path.Combine(this.ContainerDir, "app-root", "runtime", dir.Replace('_', '-'));
DirectoryUtil.EmptyDirectory(directory);
}
}
public ReturnStatus Execute()
{
Logger.Debug("Running gear command: '{0}'", Environment.CommandLine);
ReturnStatus status = new ReturnStatus();
try
{
string appUuid = Environment.GetEnvironmentVariable("OPENSHIFT_APP_UUID");
string gearUuid = Environment.GetEnvironmentVariable("OPENSHIFT_GEAR_UUID");
string appName = Environment.GetEnvironmentVariable("OPENSHIFT_APP_NAME");
string gearName = Environment.GetEnvironmentVariable("OPENSHIFT_GEAR_NAME");
string nmSpace = Environment.GetEnvironmentVariable("OPENSHIFT_NAMESPACE");
NodeConfig config = new NodeConfig();
EtcUser etcUser = new Etc(config).GetPwanam(gearUuid);
container = new ApplicationContainer(appUuid, gearUuid, etcUser, appName, gearName, nmSpace, null, null, null);
repo = new ApplicationRepository(container);
if (Prereceive)
{
Dictionary<string, object> options = new Dictionary<string, object>();
options["init"] = Init;
options["hotDeploy"] = true;
options["forceCleanBuild"] = true;
options["ref"] = container.DetermineDeploymentRef();
container.PreReceive(options);
}
else if (Postreceive)
{
RubyHash options = new RubyHash();
options["init"] = Init;
options["all"] = true;
options["reportDeployment"] = true;
options["ref"] = container.DetermineDeploymentRef();
container.PostReceive(options);
}
else if (Build)
{
string ciRepoPath = Path.Combine(Environment.GetEnvironmentVariable("OPENSHIFT_REPO_DIR"), ".git");
string repoDir = null;
if(Directory.Exists(ciRepoPath))
{
repoDir = ciRepoPath;
}
repo = new ApplicationRepository(this.container, repoDir);
string gitRef = null;
bool archive =false;
if(repoDir == null)
{
gitRef = this.container.DetermineDeploymentRef(this.RefId);
archive = true;
}
else
{
gitRef = Environment.GetEnvironmentVariable("GIT_BRANCH");
}
if(!ValidGitRef(gitRef))
{
throw new Exception(string.Format("Git ref {0} is invalid", gitRef));
}
if(archive)
{
repo.Archive(Environment.GetEnvironmentVariable("OPENSHIFT_REPO_DIR"), gitRef);
}
RubyHash options = new RubyHash();
options["ref"] = gitRef;
options["hot_deploy"] = repo.FileExists(HOT_DEPLOY_MARKER, gitRef);
options["force_clean_build"] = repo.FileExists(FORCE_CLEAN_BUILD_MARKER, gitRef);
options["git_repo"] = repo;
Console.WriteLine(container.Build(options));
}
else if (Prepare)
{
throw new NotImplementedException();
}
else if (Deploy)
{
if (Environment.GetEnvironmentVariable("OPENSHIFT_DEPLOYMENT_TYPE") == "binary")
{
throw new Exception("OPENSHIFT_DEPLOYMENT_TYPE is 'binary' - git-based deployments are disabled.");
}
string refToDeploy = container.DetermineDeploymentRef(this.DeployRefId);
if (!ValidGitRef(refToDeploy))
{
throw new Exception("Git ref " + refToDeploy + " is not valid");
}
RubyHash options = new RubyHash();
options["hot_deploy"] = this.HotDeploy;
options["force_clean_build"] = this.ForceCleanBuild;
options["ref"] = this.DeployRefId;
options["report_deployments"] = true;
options["all"] = true;
container.Deploy(options);
}
else if (Activate)
{
status.Output = container.Activate(new RubyHash
{
{"deployment_id", this.DeploymentId},
{"post_install", this.PostInstall.ToBool()},
{"all", this.All.ToBool()},
{"rotate", this.Rotation && !this.NoRotation},
{"report_deployments", true},
{"out", !this.AsJson.ToBool()}
});
}
status.ExitCode = 0;
}
catch (Exception ex)
{
Logger.Error("Error running gear command: {0} - {1}", ex.Message, ex.StackTrace);
status.Output = string.Format("{0}", ex.Message, ex.StackTrace);
status.ExitCode = 255;
}
return status;
}
public static object TransformToNativeModel(this RubyHash self)
{
return(self.value.ToDictionary(pair => TransformToNativeModel(pair.Key), pair => TransformToNativeModel(pair.Value)));
}
public RubyHash RotateAndYield(object targetGear, Dictionary<string, string> localGearEnv, RubyHash options, GearRotationCallback action)
{
RubyHash result = new RubyHash()
{
{ "status", RESULT_FAILURE },
{ "messages", new List<string>() },
{ "errors", new List<string>() }
};
string proxyCart = options["proxy_cart"];
string targetGearUuid = targetGear is string ? (string)targetGear : ((GearRegistry.Entry)targetGear).Uuid;
// TODO: vladi: check if this condition also needs boolean verification on the value in the hash
if (options["init"] == null && options["rotate"] != null && options["rotate"] && options["hot_deploy"] != null && options["hot_deploy"])
{
result["messages"].Add("Rotating out gear in proxies");
RubyHash rotateOutResults = this.UpdateProxyStatus(new RubyHash()
{
{ "action", "disable" },
{ "gear_uuid", targetGearUuid },
{ "cartridge", proxyCart }
});
result["rotate_out_results"] = rotateOutResults;
if (rotateOutResults["status"] != RESULT_SUCCESS)
{
result["errors"].Add("Rotating out gear in proxies failed.");
return result;
}
}
RubyHash yieldResult = action(targetGear, localGearEnv, options);
dynamic yieldStatus = yieldResult.Delete("status");
dynamic yieldMessages = yieldResult.Delete("messages");
dynamic yieldErrors = yieldResult.Delete("errors");
result["messages"].AddRange(yieldMessages);
result["errors"].AddRange(yieldErrors);
result = result.Merge(yieldResult);
if (yieldStatus != RESULT_SUCCESS)
{
return result;
}
if (options["init"] == null && options["rotate"] != null && options["rotate"] && options["hot_deploy"] != null && options["hot_deploy"])
{
result["messages"].Add("Rotating in gear in proxies");
RubyHash rotateInResults = this.UpdateProxyStatus(new RubyHash()
{
{ "action", "enable" },
{ "gear_uuid", targetGearUuid },
{ "cartridge", proxyCart }
});
result["rotate_in_results"] = rotateInResults;
if (rotateInResults["status"] != RESULT_SUCCESS)
{
result["errors"].Add("Rotating in gear in proxies failed");
return result;
}
}
result["status"] = RESULT_SUCCESS;
return result;
}
public void Load()
{
this.metadata = JsonConvert.DeserializeObject<RubyHash>(File.ReadAllText(file));
}
public string Prepare(RubyHash options = null)
{
if (options == null)
{
options = new RubyHash();
}
StringBuilder output = new StringBuilder();
output.AppendLine("Preparing build for deployment");
if (!options.ContainsKey("deployment_datetime"))
{
throw new ArgumentException("deployment_datetime is required");
}
string deploymentDatetime = options["deployment_datetime"].ToString();
Dictionary<string, string> env = Environ.ForGear(this.ContainerDir);
// TODO clean runtime dirs, extract archive
this.Cartridge.DoActionHook("prepare", env, options);
string deploymentId = CalculateDeploymentId();
LinkDeploymentId(deploymentDatetime, deploymentId);
try
{
SyncRuntimeRepoDirToDeployment(deploymentDatetime);
SyncRuntimeDependenciesDirToDeployment(deploymentDatetime);
SyncRuntimeBuildDependenciesDirToDeployment(deploymentDatetime);
DeploymentMetadata deploymentMetadata = DeploymentMetadataFor(deploymentDatetime);
deploymentMetadata.Id = deploymentId;
deploymentMetadata.Checksum = CalculateDeploymentChecksum(deploymentId);
deploymentMetadata.Save();
options["deployment_id"] = deploymentId;
output.AppendLine("Deployment id is " + deploymentId);
}
catch (Exception e)
{
Logger.Error("Error preparing deployment. Options: {0} - {1} - {2}", JsonConvert.SerializeObject(options), e.Message, e.StackTrace);
output.AppendLine("Error preparing deployment " + deploymentId);
UnlinkDeploymentId(deploymentId);
}
return output.ToString();
}
public MapInfoFile(Dictionary <string, object> node)
: base(
System.IO.Path.Combine(
ProjectManager.ProjectDir,
node["FileName"].ToString()
)
)
{
this.maps = new Dictionary <string, MapFile>();
this.IsSubfileProvider = true;
this.TilesetFile = ProjectManager.Components[node["TilesetProvider"].ToString()] as TilesetFile;
RubyHash mapHash = NekoKun.Serialization.RubyMarshal.RubyMarshal.Load(
new System.IO.FileStream(this.filename, System.IO.FileMode.Open, System.IO.FileAccess.Read)
) as RubyHash;
foreach (var item in mapHash)
{
string key = null;
string filename;
MapFile map = null;
if (item.Key is int)
{
key = item.Key.ToString();
filename = String.Format(node["FileNameFormat"].ToString(), (int)item.Key);
map = new MapFile(System.IO.Path.Combine(ProjectManager.ProjectDir, filename), this.TilesetFile);
}
else
{
this.MakeDirty();
continue;
}
this.maps.Add(key, map);
RubyObject info = item.Value as RubyObject;
map.Title = (info.InstanceVariable["@name"] as RubyString).Text;
map.ParentID = info.InstanceVariable["@parent_id"].ToString();
map.Order = (int)info.InstanceVariable["@order"];
/*
* parent_id
* The parent map ID.
*
* order
* The map tree display order, which is used internally.
*
* expanded
* The map tree expansion flag, which is used internally.
*
* scroll_x
* The x-axis scroll position, which is used internally.
*
* scroll_y
* The y-axis scroll position, which is used internally.
*/
}
this.maps.ToString();
nodes = new Dictionary <string, System.Windows.Forms.TreeNode>();
List <System.Windows.Forms.TreeNode> order = new List <System.Windows.Forms.TreeNode>();
foreach (var item in maps)
{
System.Windows.Forms.TreeNode node2 = new System.Windows.Forms.TreeNode(item.Value.Title);
node2.Tag = item.Value;
nodes.Add(item.Key, node2);
order.Add(node2);
}
order.Sort(
delegate(System.Windows.Forms.TreeNode me, System.Windows.Forms.TreeNode other)
{
return((me.Tag as MapFile).Order.CompareTo((other.Tag as MapFile).Order));
}
);
foreach (System.Windows.Forms.TreeNode item in order)
{
MapFile map = item.Tag as MapFile;
if (map.ParentID != null && nodes.ContainsKey(map.ParentID))
{
nodes[map.ParentID].Nodes.Add(item);
}
}
}
public string Build(RubyHash options)
{
this.State.Value(Runtime.State.BUILDING);
string deploymentDateTime = options["deployment_datetime"] != null ? options["deployment_datetime"] : LatestDeploymentDateTime();
DeploymentMetadata deploymentMetadata = DeploymentMetadataFor(deploymentDateTime);
if (!options.ContainsKey("deployment_datetime"))
{
// this will execute if coming from a CI builder, since it doesn't
// specify :deployment_datetime in the options hash
ApplicationRepository applicationRepository = options["git_repo"];
string gitRef = options["ref"];
string gitSha1 = applicationRepository.GetSha1(gitRef);
deploymentMetadata.GitSha = gitSha1;
deploymentMetadata.GitRef = gitRef;
deploymentMetadata.HotDeploy = options["hot_deploy"];
deploymentMetadata.ForceCleanBuild = options["force_clean_build"];
deploymentMetadata.Save();
}
StringBuilder buffer = new StringBuilder();
if(deploymentMetadata.ForceCleanBuild)
{
buffer.AppendLine("Force clean build enabled - cleaning dependencies");
CleanRuntimeDirs(new RubyHash() { { "dependencies", true }, { "build_dependencies", true } });
this.Cartridge.EachCartridge(delegate(Manifest cartridge) {
this.Cartridge.CreateDependencyDirectories(cartridge);
});
}
buffer.AppendLine(string.Format("Building git ref {0}, commit {1}", deploymentMetadata.GitRef, deploymentMetadata.GitSha));
Dictionary<string, string> env = Environ.ForGear(this.ContainerDir);
int deploymentsToKeep = DeploymentsToKeep(env);
try
{
Manifest primaryCartridge = this.Cartridge.GetPrimaryCartridge();
buffer.AppendLine(this.Cartridge.DoControl("update-configuration", primaryCartridge, new RubyHash() { { "pre_action_hooks_enabled", false }, { "post_action_hooks_enabled", false } }));
buffer.AppendLine(this.Cartridge.DoControl("pre-build", primaryCartridge, new RubyHash() { { "pre_action_hooks_enabled", false }, { "post_action_hooks_enabled", false } }));
buffer.AppendLine(this.Cartridge.DoControl("build", primaryCartridge, new RubyHash() { { "pre_action_hooks_enabled", false }, { "post_action_hooks_enabled", false } }));
}
catch(Exception ex)
{
buffer.AppendLine("Encountered a failure during build: " + ex.ToString());
if(deploymentsToKeep > 1)
{
buffer.AppendLine("Restarting application");
buffer.AppendLine(StartGear(new RubyHash() { { "user_initiated", true }, { "hot_deploy", deploymentMetadata.HotDeploy } }));
}
throw ex;
}
return buffer.ToString();
}
public List<RubyHash> WithGearRotation(RubyHash options, GearRotationCallback action)
{
dynamic localGearEnv = Environ.ForGear(this.ContainerDir);
Manifest proxyCart = this.Cartridge.WebProxy();
List<object> gears = new List<object>();
// TODO: vladi: verify if this is needed for scalable apps
//if (options.ContainsKey("all") && proxyCart != null)
//{
// if ((bool)options["all"])
// {
// gears = this.GearRegist.Entries["web"].Keys.ToList<object>();
// }
// else if (options.ContainsKey("gears"))
// {
// List<string> g = (List<string>)options["gears"];
// gears = this.GearRegist.Entries["web"].Keys.Where(e => g.Contains(e)).ToList<object>();
// }
// else
// {
// try
// {
// gears.Add(this.GearRegist.Entries["web"][this.Uuid]);
// }
// catch
// {
// gears.Add(this.Uuid);
// }
// }
//}
//else
{
gears.Add(this.Uuid);
}
double parallelConcurrentRatio = PARALLEL_CONCURRENCY_RATIO;
if (options.ContainsKey("parallel_concurrency_ratio"))
{
parallelConcurrentRatio = (double)options["parallel_concurrency_ratio"];
}
int batchSize = CalculateBatchSize(gears.Count, parallelConcurrentRatio);
int threads = Math.Max(batchSize, MAX_THREADS);
List<RubyHash> result = new List<RubyHash>();
// need to parallelize
foreach (var targetGear in gears)
{
result.Add(RotateAndYield(targetGear, localGearEnv, options, action));
}
return result;
}
public RubyHash UpdateRemoteProxyStatus(RubyHash args)
{
RubyHash result = new RubyHash();
string currentGear = args["current_gear"];
GearRegistry.Entry proxyGear = args["proxy_gear"];
object targetGear = args["target_gear"];
Manifest cartridge = args["cartridge"];
string action = args["action"];
bool persist = args["persist"] != null && args["persist"] == true;
object gearEnv = args["gear_env"];
if (currentGear == proxyGear.Uuid)
{
// self, no need to ssh
return this.UpdateLocalProxyStatus(new RubyHash()
{
{ "cartridge", cartridge },
{ "action", action },
{ "target_gear", targetGear },
{ "persist", persist }
});
}
string direction = action == "enable" ? "in" : "out";
string persistOption = persist ? "--persist" : "";
string url = string.Format("{0}@{1}", proxyGear.Uuid, proxyGear.ProxyHostname);
string ooSSH = @"/cygpath/c/openshift/oo-bin/oo-ssh";
string bashBinary = Path.Combine(NodeConfig.Values["SSHD_BASE_DIR"], "bin\bash.exe");
string sshCommand = string.Format("{0} {1} gear rotate-{2} --gear {3} {4} --cart {5}-{6} --as-json",
ooSSH, url, direction, targetGear, persistOption, cartridge.Name, cartridge.Version);
string bashArgs = string.Format("--norc --login -c '{0}'", sshCommand);
string command = string.Format("{0} {1}", bashBinary, bashArgs);
try
{
ProcessResult processResult = this.RunProcessInContainerContext(this.ContainerDir, command, 0);
if (string.IsNullOrEmpty(processResult.StdOut))
{
throw new Exception("No result JSON was received from the remote proxy update call");
}
result = JsonConvert.DeserializeObject<RubyHash>(processResult.StdOut);
if (!result.ContainsKey("status"))
{
throw new Exception(string.Format("Invalid result JSON received from remote proxy update call: {0}", processResult.StdOut));
}
}
catch (Exception ex)
{
result = new RubyHash()
{
{ "status", RESULT_FAILURE },
{ "proxy_gear_uuid", proxyGear.Uuid },
{ "messages", new List<string>() },
{ "errors", new List<string> { string.Format("An exception occured updating the proxy status: {0}\n{1}", ex.Message, ex.StackTrace) } }
};
}
return result;
}
public RubyHash RestartGear(object targetGear, Dictionary<string, string> localGearEnv, string cartName, dynamic options)
{
string targetGearUuid = targetGear is string ? (string)targetGear : ((GearRegistry.Entry)targetGear).Uuid;
RubyHash result = new RubyHash()
{
{ "status", RESULT_SUCCESS },
{ "messages", new List<string>() },
{ "errors", new List<string>() },
{ "target_gear_uuid", targetGearUuid }
};
try
{
if (targetGearUuid == this.Uuid)
{
result["messages"].Add(this.Cartridge.StartCartridge("restart", cartName, options));
}
else
{
string ooSSH = @"/cygpath/c/openshift/oo-bin/oo-ssh";
string bashBinary = Path.Combine(NodeConfig.Values["SSHD_BASE_DIR"], "bin\bash.exe");
if (targetGear is string)
{
targetGear = new GearRegistry.Entry(options);
}
string sshCommand = string.Format("{0} {1} gear restart --cart {2} --as-json",
ooSSH, ((GearRegistry.Entry)targetGear).ToSshUrl(), cartName);
string bashArgs = string.Format("--norc --login -c '{0}'", sshCommand);
string command = string.Format("{0} {1}", bashBinary, bashArgs);
RunProcessInContainerContext(this.ContainerDir, command);
}
}
catch(Exception ex)
{
result["errors"].Add(ex.ToString());
result["status"] = RESULT_FAILURE;
Logger.Error(ex.ToString());
}
return result;
}
/// <summary>
/// static VALUE r_object0(struct load_arg *arg, int *ivp, VALUE extmod)
/// </summary>
/// <param name="hasivp"></param>
/// <param name="ivp"></param>
/// <param name="extmod"></param>
/// <returns></returns>
public object ReadObject0(bool hasivp, ref bool ivp, List<RubyModule> extmod)
{
object v = null;
int type = ReadByte();
int id;
object link;
switch (type)
{
case RubyMarshal.Types.Link:
id = ReadLong();
if (!this.m_objects.TryGetValue(id, out link))
{
throw new InvalidDataException("dump format error (unlinked)");
}
v = link;
if (this.m_proc != null)
v = this.m_proc(v);
break;
case RubyMarshal.Types.InstanceVariable:
{
bool ivar = true;
v = ReadObject0(ref ivar, extmod);
bool hasenc = false;
if (ivar) ReadInstanceVariable(v, ref hasenc);
}
break;
case RubyMarshal.Types.Extended:
{
RubyModule m = RubyModule.GetModule(ReadUnique());
if (extmod == null)
extmod = new List<RubyModule>();
extmod.Add(m);
v = ReadObject0(extmod);
RubyObject fobj = v as RubyObject;
if (fobj != null)
{
fobj.ExtendModules.AddRange(extmod);
}
}
break;
case RubyMarshal.Types.UserClass:
{
RubyClass c = RubyClass.GetClass(ReadUnique());
v = ReadObject0(extmod);
if (v is RubyObject)
(v as RubyObject).ClassName = c.Symbol;
}
break;
case RubyMarshal.Types.Nil:
v = RubyNil.Instance;
v = Leave(v);
break;
case RubyMarshal.Types.True:
v = true;
v = Leave(v);
break;
case RubyMarshal.Types.False:
v = false;
v = Leave(v);
break;
case RubyMarshal.Types.Fixnum:
v = ReadLong();
v = Leave(v);
break;
case RubyMarshal.Types.Float:
{
double d;
RubyString fstr = ReadString();
string str = fstr.Text;
if (str == "inf")
d = double.PositiveInfinity;
else if (str == "-inf")
d = double.NegativeInfinity;
else if (str == "nan")
d = double.NaN;
else
{
if (str.Contains("\0"))
{
str = str.Remove(str.IndexOf("\0"));
}
d = Convert.ToDouble(str);
}
v = new RubyFloat(d);
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.Bignum:
{
int sign = 0;
switch (ReadByte())
{
case 0x2b:
sign = 1;
break;
case 0x2d:
sign = -1;
break;
default:
sign = 0;
break;
}
int num3 = ReadLong();
int index = num3 / 2;
int num5 = (num3 + 1) / 2;
uint[] data = new uint[num5];
for (int i = 0; i < index; i++)
{
data[i] = m_reader.ReadUInt32();
}
if (index != num5)
{
data[index] = m_reader.ReadUInt16();
}
v = new RubyBignum(sign, data);
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.String:
v = Entry(ReadString());
v = Leave(v);
break;
case RubyMarshal.Types.Regexp:
{
RubyString str = ReadString();
int options = ReadByte();
bool has_encoding = false;
int idx = Prepare();
if (hasivp)
{
ReadInstanceVariable(str, ref has_encoding);
ivp = false;
}
if (!has_encoding)
{
// TODO: 1.8 compatibility; remove escapes undefined in 1.8
/*
char *ptr = RSTRING_PTR(str), *dst = ptr, *src = ptr;
long len = RSTRING_LEN(str);
long bs = 0;
for (; len-- > 0; *dst++ = *src++) {
switch (*src) {
case '\\': bs++; break;
case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
case 'm': case 'o': case 'p': case 'q': case 'u': case 'y':
case 'E': case 'F': case 'H': case 'I': case 'J': case 'K':
case 'L': case 'N': case 'O': case 'P': case 'Q': case 'R':
case 'S': case 'T': case 'U': case 'V': case 'X': case 'Y':
if (bs & 1) --dst;
default: bs = 0; break;
}
}
rb_str_set_len(str, dst - ptr);
*/
}
v = Entry0(new RubyRegexp(str, (RubyRegexpOptions)options), idx);
v = Leave(v);
}
break;
case RubyMarshal.Types.Array:
{
int len = ReadLong();
RubyArray ary = new RubyArray();
v = ary;
v = Entry(v);
while (len-- > 0)
{
ary.Push(ReadObject());
}
v = Leave(v);
}
break;
case RubyMarshal.Types.Hash:
case RubyMarshal.Types.HashWithDefault:
{
int len = ReadLong();
RubyHash hash = new RubyHash();
v = hash;
v = Entry(v);
while (len-- > 0)
{
object key = ReadObject();
object value = ReadObject();
hash.Add(key, value);
}
if (type == RubyMarshal.Types.HashWithDefault)
{
hash.DefaultValue = ReadObject();
}
v = Leave(v);
}
break;
case RubyMarshal.Types.Struct:
{
int idx = Prepare();
RubyStruct obj = new RubyStruct();
RubySymbol klass = ReadUnique();
obj.ClassName = klass;
int len = ReadLong();
v = obj;
v = Entry0(v, idx);
while (len-- > 0)
{
RubySymbol key = ReadSymbol();
object value = ReadObject();
obj.InstanceVariable[key] = value;
}
v = Leave(v);
}
break;
case RubyMarshal.Types.UserDefined:
{
RubySymbol klass = ReadUnique();
RubyString data = ReadString();
if (hasivp)
{
ReadInstanceVariable(data);
ivp = false;
}
RubyUserdefinedDumpObject obj = new RubyUserdefinedDumpObject();
obj.ClassName = klass;
obj.DumpedObject = data.Raw;
v = obj;
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.UserMarshal:
{
RubySymbol klass = ReadUnique();
FuzzyUserdefinedMarshalDumpObject obj = new FuzzyUserdefinedMarshalDumpObject();
v = obj;
if (extmod != null)
AppendExtendedModule(obj, extmod);
v = Entry(v);
object data = ReadObject();
obj.ClassName = klass;
obj.DumpedObject = data;
v = Leave(v);
if (extmod != null)
{
extmod.Clear();
}
}
break;
case RubyMarshal.Types.Object:
{
int idx = Prepare();
RubyObject obj = new RubyObject();
RubySymbol klass = ReadUnique();
obj.ClassName = klass;
v = obj;
v = Entry0(v, idx);
ReadInstanceVariable(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.Class:
{
RubyString str = ReadString();
v = RubyClass.GetClass(RubySymbol.GetSymbol(str));
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.Module:
{
RubyString str = ReadString();
v = RubyModule.GetModule(RubySymbol.GetSymbol(str));
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.Symbol:
if (hasivp)
{
v = ReadSymbolReal(ivp);
ivp = false;
}
else
{
v = ReadSymbolReal(false);
}
v = Leave(v);
break;
case RubyMarshal.Types.SymbolLink:
v = ReadSymbolLink();
break;
case RubyMarshal.Types.Data:
/* TODO: Data Support
{
VALUE klass = path2class(r_unique(arg));
VALUE oldclass = 0;
v = obj_alloc_by_klass(klass, arg, &oldclass);
if (!RB_TYPE_P(v, T_DATA)) {
rb_raise(rb_eArgError, "dump format error");
}
v = r_entry(v, arg);
if (!rb_respond_to(v, s_load_data)) {
rb_raise(rb_eTypeError, "class %s needs to have instance method `_load_data'", rb_class2name(klass));
}
rb_funcall(v, s_load_data, 1, r_object0(arg, 0, extmod));
check_load_arg(arg, s_load_data);
v = r_leave(v, arg);
}
*/
case RubyMarshal.Types.ModuleOld:
/*
TODO: ModuleOld Support
{
volatile VALUE str = r_bytes(arg);
v = rb_path_to_class(str);
v = r_entry(v, arg);
v = r_leave(v, arg);
}
*/
default:
throw new InvalidDataException(string.Format("dump format error(0x{0:X2})", type));
}
return v;
}
private RubyHash ActivateLocalGear(dynamic options)
{
string deploymentId = options["deployment_id"];
Logger.Debug("Activating local gear with deployment id {0}", deploymentId);
RubyHash result = new RubyHash();
result["status"] = RESULT_FAILURE;
result["gear_uuid"] = this.Uuid;
result["deployment_id"] = deploymentId;
result["messages"] = new List<string>();
result["errors"] = new List<string>();
if (!DeploymentExists(deploymentId))
{
Logger.Warning("No deployment with id {0} found on gear", deploymentId);
result["errors"].Add(string.Format("No deployment with id {0} found on gear", deploymentId));
return result;
}
try
{
string deploymentDateTime = GetDeploymentDateTimeForDeploymentId(deploymentId);
string deploymentDir = Path.Combine(this.ContainerDir, "app-deployments", deploymentDateTime);
Dictionary<string, string> gearEnv = Environ.ForGear(this.ContainerDir);
string output = string.Empty;
Logger.Debug("Current deployment state for deployment {0} is {1}", deploymentId, this.State.Value());
if (Runtime.State.STARTED.EqualsString(State.Value()))
{
options["exclude_web_proxy"] = true;
output = StopGear(options);
result["messages"].Add(output);
}
SyncDeploymentRepoDirToRuntime(deploymentDateTime);
SyncDeploymentDependenciesDirToRuntime(deploymentDateTime);
SyncDeploymentBuildDependenciesDirToRuntime(deploymentDateTime);
UpdateCurrentDeploymentDateTimeSymlink(deploymentDateTime);
FixHomeDir();
Manifest primaryCartridge = this.Cartridge.GetPrimaryCartridge();
this.Cartridge.DoControl("update-configuration", primaryCartridge);
result["messages"].Add("Starting application " + ApplicationName);
Dictionary<string, object> opts = new Dictionary<string,object>();
opts["secondary_only"] = true;
opts["user_initiated"] = true;
opts["hot_deploy"] = options["hot_deploy"];
output = StartGear(opts);
result["messages"].Add(output);
this.State.Value(Runtime.State.DEPLOYING);
opts = new Dictionary<string, object>();
opts["pre_action_hooks_enabled"] = false;
opts["prefix_action_hooks"] = false;
output = this.Cartridge.DoControl("deploy", primaryCartridge, opts);
result["messages"].Add(output);
opts = new Dictionary<string, object>();
opts["primary_only"] = true;
opts["user_initiated"] = true;
opts["hot_deploy"] = options["hot_deploy"];
output = StartGear(opts);
result["messages"].Add(output);
opts = new Dictionary<string, object>();
opts["pre_action_hooks_enabled"] = false;
opts["prefix_action_hooks"] = false;
output = this.Cartridge.DoControl("post-deploy", primaryCartridge, opts);
result["messages"].Add(output);
if (options.ContainsKey("post_install"))
{
string primaryCartEnvDir = Path.Combine(this.ContainerDir, primaryCartridge.Dir, "env");
Dictionary<string, string> primaryCartEnv = Environ.Load(primaryCartEnvDir);
string ident = (from kvp in primaryCartEnv
where Regex.Match(kvp.Key, "^OPENSHIFT_.*_IDENT").Success
select kvp.Value).FirstOrDefault();
string version = Manifest.ParseIdent(ident)[2];
this.Cartridge.PostInstall(primaryCartridge, version);
}
DeploymentMetadata deploymentMetadata = DeploymentMetadataFor(deploymentDateTime);
deploymentMetadata.RecordActivation();
deploymentMetadata.Save();
if (options.ContainsKey("report_deployments") && gearEnv["OPENSHIFT_APP_DNS"] == gearEnv["OPENSHIFT_GEAR_DNS"])
{
ReportDeployments(gearEnv);
}
result["status"] = RESULT_SUCCESS;
}
catch(Exception e)
{
result["status"] = RESULT_FAILURE;
result["errors"].Add(string.Format("Error activating gear: {0}", e.ToString()));
}
return result;
}
public List<RubyHash> Restart(string cartName, RubyHash options)
{
List<RubyHash> result = WithGearRotation(options,
(GearRotationCallback)delegate(object targetGear, Dictionary<string, string> localGearEnv, RubyHash opts)
{
return RestartGear(targetGear, localGearEnv, cartName, opts);
});
return result;
}
public string Activate(RubyHash options = null)
{
Logger.Debug("Activating gear {0}", this.Uuid);
if(options == null)
{
options = new RubyHash();
}
bool useOutput = options.ContainsKey("out") && options["out"];
StringBuilder output = new StringBuilder();
dynamic result = new Dictionary<string, object>();
if (useOutput)
{
output.Append("Activating deployment");
}
if (!options.ContainsKey("deployment_id"))
{
throw new Exception("deployment_id must be supplied");
}
string deploymentId = options["deployment_id"];
string deploymentDateTime = GetDeploymentDateTimeForDeploymentId(deploymentId);
DeploymentMetadata deploymentMetadata = DeploymentMetadataFor(deploymentDateTime);
options["hot_deploy"] = deploymentMetadata.HotDeploy;
if (options.ContainsKey("post_install") || options.ContainsKey("restore"))
{
options["hot_deploy"] = false;
}
List<RubyHash> parallelResults = WithGearRotation(options, (GearRotationCallback)delegate(object targetGear, Dictionary<string, string> localGearEnv, RubyHash opts)
{
string targetGearUuid;
if (targetGear is string)
{
targetGearUuid = targetGear.ToString();
}
else
{
targetGearUuid = ((Model.GearRegistry.Entry)targetGear).Uuid;
}
if (targetGearUuid == this.Uuid)
{
return ActivateLocalGear(options);
}
else
{
return ActivateRemoteGear((GearRegistry.Entry)targetGear, localGearEnv, options);
}
});
List<string> activatedGearUuids = new List<string>();
if ((options.ContainsKey("all") && options["all"]) || (options.ContainsKey("gears") && options["gears"]))
{
result["status"] = RESULT_SUCCESS;
result["gear_results"] = new Dictionary<string, object>();
foreach (RubyHash gearResult in parallelResults)
{
string gearUuid = gearResult["gear_uuid"];
activatedGearUuids.Add(gearUuid);
result["gear_results"][gearUuid] = gearResult;
if (gearResult["status"] != RESULT_SUCCESS)
{
result["status"] = RESULT_FAILURE;
}
}
}
else
{
activatedGearUuids.Add(this.Uuid);
result = parallelResults[0];
}
output.Append(JsonConvert.SerializeObject(result));
return output.ToString();
}
private RubyHash ActivateRemoteGear(GearRegistry.Entry gear, Dictionary<string, string> gearEnv, RubyHash options)
{
string gearUuid = gear.Uuid;
RubyHash result = new RubyHash();
result["status"] = RESULT_FAILURE;
result["gear_uuid"] = this.Uuid;
result["deployment_id"] = options["deployment_id"];
result["messages"] = new List<string>();
result["errors"] = new List<string>();
string postInstallOptions = options["post_install"] == true ? "--post-install" : "";
result["messages"].Add(string.Format("Activating gear {0}, deployment id: {1}, {2}", gearUuid, options["deployment_id"], postInstallOptions));
try
{
string ooSSH = @"/cygpath/c/openshift/oo-bin/oo-ssh";
string bashBinary = Path.Combine(NodeConfig.Values["SSHD_BASE_DIR"], "bin\bash.exe");
string sshCommand = string.Format("{0} {1} gear activate {2} --as-json {3} --no-rotation",
ooSSH, gear.ToSshUrl(), options["deployment_id"], postInstallOptions);
string bashArgs = string.Format("--norc --login -c '{0}'", sshCommand);
string command = string.Format("{0} {1}", bashBinary, bashArgs);
string output = RunProcessInContainerContext(this.ContainerDir, command).StdOut;
if (string.IsNullOrEmpty(output))
{
throw new Exception("No result JSON was received from the remote activate call");
}
Dictionary<string, object> activateResult = JsonConvert.DeserializeObject<Dictionary<string, object>>(output);
if (!activateResult.ContainsKey("status"))
{
throw new Exception("Invalid result JSON received from remote activate call");
}
result["messages"].Add(activateResult["messages"]);
result["errors"].Add(activateResult["errors"]);
result["status"] = activateResult["status"];
}
catch (Exception e)
{
result["errors"].Add("Gear activation failed: " + e.ToString());
}
return result;
}
public void Test_FacterOpenshift()
{
RubyHash facts = Uhuru.Openshift.Runtime.Utils.Facter.GetOpenshiftFacts();
Assert.IsTrue(facts.ContainsKey("node_profile"));
}
public string UpdateProxyStatusForGear(RubyHash options)
{
string action = options["action"];
if (action != "enable" && action != "disable")
{
new ArgumentException("action must either be :enable or :disable");
}
string gearUuid = options["gear_uuid"];
if (gearUuid == null)
{
new ArgumentException("gear_uuid is required");
}
Manifest cartridge = options["cartridge"] ?? this.Cartridge.WebProxy();
if (cartridge == null)
{
throw new ArgumentNullException("Unable to update proxy status - no proxy cartridge found");
}
bool persist = options["persist"] != null && options["persist"] == true;
string control = string.Format("{0}-server", action);
List<string> args = new List<string>();
if (persist)
{
args.Add("persist");
}
args.Add(gearUuid);
return this.Cartridge.DoControl(
control, cartridge, new Dictionary<string, object>()
{
{ "args", string.Join(" ", args) },
{ "pre_action_hooks_enabled", false },
{ "post_action_hooks_enabled", false }
});
}
public RubyHash UpdateLocalProxyStatus(RubyHash args)
{
RubyHash result = new RubyHash();
object cartridge = args["cartridge"];
object action = args["action"];
object targetGear =args["target_gear"];
object persist = args["persist"];
try
{
string output = this.UpdateProxyStatusForGear(new RubyHash(){
{ "cartridge", cartridge },
{ "action", action },
{ "gear_uuid", targetGear },
{ "persist", persist }
});
result = new RubyHash()
{
{ "status", RESULT_SUCCESS },
{ "proxy_gear_uuid", this.Uuid },
{ "target_gear_uuid", targetGear },
{ "messages", new List<string>() },
{ "errors", new List<string>() }
};
}
catch (Exception ex)
{
result = new RubyHash()
{
{ "status", RESULT_FAILURE },
{ "proxy_gear_uuid", this.Uuid },
{ "target_gear_uuid", targetGear },
{ "messages", new List<string>() },
{ "errors", new List<string>() { string.Format("An exception occured updating the proxy status: {0}\n{1}", ex.Message, ex.StackTrace) } }
};
}
return result;
}
public RubyHash UpdateProxyStatus(RubyHash options)
{
string action = options["action"];
if (action != "enable" && action != "disable")
{
throw new ArgumentException("action must either be :enable or :disable");
}
if (options["gear_uuid"] == null)
{
throw new ArgumentException("gear_uuid is required");
}
string gearUuid = options["gear_uuid"];
Manifest cartridge;
if (options["cartridge"] == null)
{
cartridge = this.Cartridge.WebProxy();
}
else
{
cartridge = options["cartridge"];
}
if (cartridge == null)
{
throw new ArgumentException("Unable to update proxy status - no proxy cartridge found");
}
dynamic persist = options["persist"];
Dictionary<string, string> gearEnv = Environ.ForGear(this.ContainerDir);
RubyHash result = new RubyHash() {
{ "status", RESULT_SUCCESS },
{ "target_gear_uuid", gearUuid },
{ "proxy_results", new RubyHash() }
};
RubyHash gearResult = new RubyHash();
if (gearEnv["OPENSHIFT_APP_DNS"] != gearEnv["OPENSHIFT_GEAR_DNS"])
{
gearResult = this.UpdateLocalProxyStatus(new RubyHash(){
{ "cartridge", cartridge },
{ "action", action },
{ "proxy_gear", this.Uuid },
{ "target_gear", gearUuid },
{ "persist", persist }
});
result["proxy_results"][this.Uuid] = gearResult;
}
else
{
// only update the other proxies if we're the currently elected proxy
// TODO the way we determine this needs to change so gears other than
// the initial proxy gear can be elected
GearRegistry.Entry[] proxyEntries = this.gearRegistry.Entries["proxy"].Values.ToArray();
// TODO: vladi: Make this parallel
RubyHash[] parallelResults = proxyEntries.Select(entry =>
this.UpdateRemoteProxyStatus(new RubyHash()
{
{ "current_gear", this.Uuid },
{ "proxy_gear", entry },
{ "target_gear", gearUuid },
{ "cartridge", cartridge },
{ "action", action },
{ "persist", persist },
{ "gear_env", gearEnv }
})).ToArray();
foreach (RubyHash parallelResult in parallelResults)
{
if (parallelResult.ContainsKey("proxy_results"))
{
result["proxy_results"] = result["proxy_results"].Merge(parallelResult["proxy_results"]);
}
else
{
result["proxy_results"][parallelResult["proxy_gear_uuid"]] = parallelResult;
}
}
}
// if any results failed, consider the overall operation a failure
foreach (RubyHash proxyResult in result["proxy_results"].Values)
{
if (proxyResult["status"] != RESULT_SUCCESS)
{
result["status"] = RESULT_FAILURE;
}
}
return result;
}
public void PostReceive(RubyHash options)
{
Logger.Debug("Running post receive for gear {0}", this.Uuid);
Dictionary<string, string> gearEnv = Environ.ForGear(this.ContainerDir);
string repoDir = Path.Combine(this.ContainerDir, "app-root", "runtime", "repo");
Directory.CreateDirectory(repoDir);
ApplicationRepository applicationRepository = new ApplicationRepository(this);
applicationRepository.Archive(repoDir, options["ref"]);
options["deployment_datetime"] = this.LatestDeploymentDateTime();
Build(options);
Logger.Debug("Running post receive - prepare for gear {0}", this.Uuid);
Prepare(options);
Logger.Debug("Running post receive - distribute for gear {0}", this.Uuid);
Distribute(options);
Logger.Debug("Running post receive - activate for gear {0}", this.Uuid);
Activate(options);
}
public DeploymentMetadata(ApplicationContainer container, string deploymentDatetime)
{
this.file = Path.Combine(container.ContainerDir, "app-deployments", deploymentDatetime, "metadata.json");
if(File.Exists(file))
{
Load();
}
else
{
using (File.Create(this.file)) { };
container.SetRWPermissions(this.file);
this.metadata = this.defaults;
Save();
}
}
public string Deploy(RubyHash options)
{
StringBuilder output = new StringBuilder();
if (!options.ContainsKey("artifact_url"))
{
output.AppendLine(PreReceive(options));
PostReceive(options);
}
else
{
output.AppendLine(DeployBinaryArtifact(options));
}
return output.ToString();
}
public static IEnumerable<ApplicationContainer> All(Hourglass hourglass = null, bool loadenv = true)
{
EtcUser[] users = new Etc(NodeConfig.Values).GetAllUsers();
foreach (EtcUser user in users)
{
if (user.Gecos.StartsWith("openshift_service"))
{
RubyHash env = new RubyHash();
string gearNamespace = null;
if (loadenv)
{
env = new RubyHash(Environ.Load(new string[] { Path.Combine(user.Dir, ".env") }));
}
if (env.ContainsKey("OPENSHIFT_GEAR_DNS"))
{
gearNamespace = env["OPENSHIFT_GEAR_DNS"];
}
ApplicationContainer app = null;
try
{
app = new ApplicationContainer(env["OPENSHIFT_APP_UUID"],
user.Name, user, env["OPENSHIFT_APP_NAME"], env["OPENSHIFT_GEAR_NAME"], gearNamespace, null, null, hourglass);
}
catch (Exception ex)
{
Logger.Error("Failed to instantiate ApplicationContainer for uid {0}/uuid {1}: {2}",
user.Uid, env["OPENSHIFT_APP_UUID"], ex.Message);
Logger.Error("Stacktrace: {0}", ex.StackTrace);
continue;
}
yield return app;
}
}
}
public static RubyHash NodeUtilization()
{
RubyHash result = new RubyHash();
Common.Config resource = Node.ResourceLimits;
if (resource == null)
{
return result;
}
result["node_profile"] = resource.Get("node_profile", Node.DEFAULT_NODE_PROFILE);
result["quota_blocks"] = resource.Get("quota_blocks", Node.DEFAULT_QUOTA_BLOCKS);
result["quota_files"] = resource.Get("quota_files", Node.DEFAULT_QUOTA_FILES);
result["no_overcommit_active"] = Boolean.Parse(resource.Get("no_overcommit_active", Node.DEFAULT_NO_OVERCOMMIT_ACTIVE));
result["max_active_gears"] = Convert.ToInt32(resource.Get("max_active_gears", Node.DEFAULT_MAX_ACTIVE_GEARS));
//
// Count number of git repos and gear status counts
//
result["git_repos_count"] = 0;
result["gears_total_count"] = 0;
result["gears_idled_count"] = 0;
result["gears_stopped_count"] = 0;
result["gears_started_count"] = 0;
result["gears_deploying_count"] = 0;
result["gears_unknown_count"] = 0;
foreach (ApplicationContainer app in ApplicationContainer.All(null, false))
{
result["gears_total_count"] += 1;
switch (app.State.Value())
{
case "building":
case "deploying":
case "new":
result["gears_deploying_count"] += 1;
break;
case "started":
result["gears_started_count"] += 1;
break;
case "idle":
result["gears_idled_count"] += 1;
break;
case "stopped":
result["gears_stopped_count"] += 1;
break;
case "unknown":
result["gears_unknown_count"] += 1;
break;
}
}
// consider a gear active unless explicitly not
result["gears_active_count"] = result["gears_total_count"] - result["gears_idled_count"] - result["gears_stopped_count"];
result["gears_usage_pct"] = result["max_active_gears"] == 0 ? 0.0f : (result["gears_total_count"] * 100.0f) / result["max_active_gears"];
result["gears_active_usage_pct"] = result["max_active_gears"] == 0 ? 0.0f : (result["gears_active_count"] * 100.0f) / result["max_active_gears"];
result["capacity"] = result["gears_usage_pct"].ToString();
result["active_capacity"] = result["gears_active_usage_pct"].ToString();
return result;
}
public ReturnStatus Execute()
{
ReturnStatus returnStatus = new ReturnStatus();
try
{
NodeConfig config = new NodeConfig();
string gearPath = config.Get("GEAR_BASE_DIR");
string[] folders = Directory.GetDirectories(gearPath);
List<RubyHash> endpoints = new List<RubyHash>();
RubyHash outputHash = new RubyHash();
foreach (string folder in folders)
{
string folderName = Path.GetFileName(folder);
if (!folderName.StartsWith("."))
{
ApplicationContainer container = ApplicationContainer.GetFromUuid(folderName);
Dictionary<string, string> env = Environ.ForGear(container.ContainerDir);
container.Cartridge.EachCartridge(cart =>
{
cart.Endpoints.ForEach(endpoint =>
{
RubyHash endpointHash = new RubyHash();
endpointHash.Add("cartridge_name", string.Format("{0}-{1}", cart.Name, cart.Version));
if (env.ContainsKey(endpoint.PublicPortName))
{
endpointHash.Add("external_port", env[endpoint.PublicPortName]);
}
else
{
endpointHash.Add("external_port", null);
}
endpointHash.Add("internal_address", env[endpoint.PrivateIpName]);
endpointHash.Add("internal_port", endpoint.PrivatePort);
endpointHash.Add("protocols", endpoint.Protocols);
endpointHash.Add("type", new List<string>());
if (cart.WebProxy)
{
endpointHash["protocols"] = container.Cartridge.GetPrimaryCartridge().Endpoints.First().Protocols;
endpointHash["type"] = new List<string>() { "load_balancer" };
}
else if (cart.WebFramework)
{
endpointHash["type"] = new List<string>() { "web_framework" };
}
else if (cart.Categories.Contains("database"))
{
endpointHash["type"] = new List<string>() { "web_framework" };
}
else if (cart.Categories.Contains("plugin"))
{
endpointHash["type"] = new List<string>() { "plugin" };
}
else
{
endpointHash["type"] = new List<string>() { "other" };
}
if (endpoint.Mappings != null && endpoint.Mappings.Count > 0)
{
List<RubyHash> mappingsList = new List<RubyHash>();
foreach (Uhuru.Openshift.Common.Models.Endpoint.Mapping mapping in endpoint.Mappings)
{
RubyHash mappings = new RubyHash();
mappings.Add("frontend", mapping.Frontend);
mappings.Add("backend", mapping.Backend);
mappingsList.Add(mappings);
}
endpointHash.Add("mappings", mappingsList);
}
endpoints.Add(endpointHash);
});
});
if (endpoints.Count > 0)
{
outputHash.Add(folderName, endpoints);
}
}
}
string output = Newtonsoft.Json.JsonConvert.SerializeObject(outputHash);
returnStatus.Output = output;
returnStatus.ExitCode = 0;
}
catch (Exception ex)
{
Logger.Error("Error running get-all-gears-endpoints-action command: {0} - {1}", ex.Message, ex.StackTrace);
returnStatus.Output = ex.ToString();
returnStatus.ExitCode = 1;
}
return returnStatus;
}
