initial commit

Author: Plaristote

.gitattributes

@@ -0,0 +1,19 @@
+# This is a good default: files that are auto-detected by git to be text are
+# converted to the platform-native line ending (LF on Unix, CRLF on Windows)
+# in the working tree and to LF in the repository.
+#
+* text=auto
+
+# Use `eol=crlf` for files that should have the CRLF line ending both in the
+# working tree (even on Unix) and in the repository.
+#
+#*.bat text eol=crlf
+
+# Use `eol=lf` for files that should have the LF line ending both in the
+# working tree (even on Windows) and in the repository.
+#
+#*.sh text eol=lf
+
+# Use `binary` to make sure certain files are never auto-detected as text.
+#
+#*.png binary

.gitignore

@@ -0,0 +1,30 @@
+.bdep/
+
+# Local default options files.
+#
+.build2/local/
+
+# Compiler/linker output.
+#
+*.d
+*.t
+*.i
+*.i.*
+*.ii
+*.ii.*
+*.o
+*.obj
+*.gcm
+*.pcm
+*.ifc
+*.so
+*.dll
+*.a
+*.lib
+*.exp
+*.pdb
+*.ilk
+*.exe
+*.exe.dlls/
+*.exe.manifest
+*.pc

README.md

@@ -0,0 +1,3 @@
+# crails-deploy
+
+C++ executable

build/.gitignore

@@ -0,0 +1,4 @@
+/config.build
+/root/
+/bootstrap/
+build/

build/bootstrap.build

@@ -0,0 +1,7 @@
+project = crails-deploy
+
+using version
+using config
+using test
+using install
+using dist

build/root.build

@@ -0,0 +1,20 @@
+# Uncomment to suppress warnings coming from external libraries.
+#
+#cxx.internal.scope = current
+
+cxx.std = latest
+
+using cxx
+
+hxx{*}: extension = hpp
+ixx{*}: extension = ixx
+txx{*}: extension = txx
+cxx{*}: extension = cpp
+
+# Assume headers are importable unless stated otherwise.
+#
+hxx{*}: cxx.importable = true
+
+# The test target for cross-testing (running tests under Wine, etc).
+#
+test.target = $cxx.target

buildfile

@@ -0,0 +1 @@
+./: {*/ -build/} doc{README.md} manifest

crails-deploy/.gitignore

@@ -0,0 +1,5 @@
+crails-deploy
+
+# Testscript output directory (can be symlink).
+#
+test-crails-deploy

crails-deploy/buildfile

@@ -0,0 +1,9 @@
+libs =
+import libs += libcrails-cli%lib{crails-cli}
+import libs += libcrails-ssh%lib{crails-ssh}
+import libs += libcrails-logger%lib{crails-logger}
+
+exe{crails-deploy}: {hxx ixx txx cxx}{**} $libs testscript
+
+cxx.poptions =+ "-I$out_root" "-I$src_root"
+cxx.loptions =+ "-Wl,--start-group" -lssh -lcrypto -lssl -lboost_program_options

crails-deploy/deploy_application.cpp

@@ -0,0 +1,46 @@
+#include "deploy_application.hpp"
+
+using namespace Crails;
+using namespace std;
+
+void ApplicationPackageDeploy::install_application()
+{
+  deploy_package();
+  create_runtime_directory();
+  create_log_directory();
+}
+
+void ApplicationPackageDeploy::deploy_package()
+{
+  stringstream command;
+  int rc;
+
+  if (sudo) command << "sudo ";
+  command << "tar xf \"" << tmp_filepath << "\" --directory /";
+  ssh.make_scp_session("/tmp", Ssh::WriteMode)->push_file(package, tmp_filename);
+  rc = ssh.exec(command.str(), std_out);
+  if (rc != 0)
+    throw std::runtime_error("could not extract package");
+  ssh.exec("rm \"" + tmp_filepath + '"', null_output);
+}
+
+void ApplicationPackageDeploy::create_runtime_directory()
+{
+  if (mkdir(runtime_directory) != 0)
+    throw std::runtime_error("could not create runtime directory");
+}
+
+void ApplicationPackageDeploy::create_log_directory()
+{
+  if (mkdir(log_directory) != 0)
+    throw std::runtime_error("could not create log directory");
+}
+
+int ApplicationPackageDeploy::mkdir(const std::string& path)
+{
+  stringstream command;
+
+  if (sudo) command << "sudo ";
+  command << "mkdir -p \"" << path << '"';
+  return ssh.exec(command.str(), null_output);
+}

crails-deploy/deploy_application.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include "settings.hpp"
+#include "ssh.hpp"
+
+class ApplicationPackageDeploy :
+  protected virtual ApplicationDeploySettings,
+  public virtual ApplicationDeploySsh
+{
+public:
+  void install_application();
+
+private:
+  void deploy_package();
+  void create_runtime_directory();
+  void create_log_directory();
+
+  int mkdir(const std::string& path);
+};

crails-deploy/deploy_permissions.cpp

@@ -0,0 +1,61 @@
+#include "deploy_permissions.hpp"
+
+using namespace std;
+using namespace Crails;
+
+void ApplicationPermissionDeploy::set_permissions()
+{
+  set_permissions_on(
+    runtime_directory,
+    "gu+rw,o-rwx"
+  );
+  set_permissions_on(
+    log_directory,
+    "gu+rw,o-rwx"
+  );
+  set_permissions_on(
+    root + "/share/" + app_name,
+    "gu+r,o-rwx"
+  );
+  set_permissions_on(
+    root + "/bin/" + app_name,
+    "gu+rx,o-rwx"
+  );
+}
+
+void ApplicationPermissionDeploy::set_permissions_on(const std::string& target, const std::string permissions)
+{
+  int rc =
+    chown(target) +
+    chgrp(target) +
+    chmod(target, permissions);
+  if (rc != 0)
+    throw std::runtime_error("could not set permissions");
+}
+
+int ApplicationPermissionDeploy::chown(const std::string& target)
+{
+  stringstream command;
+
+  if (sudo) command << "sudo ";
+  command << "chown -R \"" << app_user << "\" \"" << target << '"';
+  return ssh.exec(command.str(), null_output);
+}
+
+int ApplicationPermissionDeploy::chgrp(const std::string& target)
+{
+  stringstream command;
+
+  if (sudo) command << "sudo ";
+  command << "chgrp -R \"" << app_group << "\" \"" << target << '"';
+  return ssh.exec(command.str(), null_output);
+}
+
+int ApplicationPermissionDeploy::chmod(const std::string& target, const std::string& permissions)
+{
+  stringstream command;
+
+  if (sudo) command << "sudo ";
+  command << "chmod -R " << permissions << " \"" << target << '"';
+  return ssh.exec(command.str(), null_output);
+}

crails-deploy/deploy_permissions.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include "settings.hpp"
+#include "ssh.hpp"
+
+class ApplicationPermissionDeploy :
+  protected virtual ApplicationDeploySettings,
+  protected virtual ApplicationDeploySsh
+{
+public:
+  void set_permissions();
+
+private:
+  void set_permissions_on(const std::string& target, const std::string permissions);
+
+  int chown(const std::string& target);
+  int chgrp(const std::string& target);
+  int chmod(const std::string& target, const std::string& permissions);
+};

crails-deploy/deploy_user.cpp

@@ -0,0 +1,60 @@
+#include "deploy_user.hpp"
+
+using namespace Crails;
+using namespace std;
+
+void ApplicationUserDeploy::prepare_application_user()
+{
+  if (!group_exists())
+    create_group();
+  if (!user_exists())
+    create_user();
+  else
+    assign_group();
+}
+
+bool ApplicationUserDeploy::user_exists()
+{
+  return ssh.exec("id -u \"" + app_user + '"', null_output) == 0;
+}
+
+bool ApplicationUserDeploy::group_exists()
+{
+  return ssh.exec("grep \"^" + app_group + ":\" /etc/group", null_output) == 0;
+}
+
+void ApplicationUserDeploy::create_user()
+{
+  stringstream command;
+  int rc;
+
+  if (sudo) command << "sudo ";
+  command << "useradd --no-create-home \"" << app_user << '"'
+          << " -g \"" << app_group << '"';
+  rc = ssh.exec(command.str(), null_output);
+}
+
+void ApplicationUserDeploy::create_group()
+{
+  stringstream command;
+  int rc;
+
+  if (sudo) command << "sudo ";
+  command << "groupadd \"" << app_group << '"';
+  rc = ssh.exec(command.str(), null_output);
+  if (rc != 0)
+    throw std::runtime_error("could not create app group");
+}
+
+void ApplicationUserDeploy::assign_group()
+{
+  stringstream command;
+  int rc;
+
+  if (sudo) command << "sudo ";
+  command << "usermod -g \"" << app_group << '"'
+          << " \"" << app_user << '"';
+  rc = ssh.exec(command.str(), null_output);
+  if (rc != 0)
+    throw std::runtime_error("could not assign group to user");
+}

crails-deploy/deploy_user.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include "settings.hpp"
+#include "ssh.hpp"
+
+class ApplicationUserDeploy :
+  protected virtual ApplicationDeploySettings,
+  protected virtual ApplicationDeploySsh
+{
+public:
+  void prepare_application_user();
+
+private:
+  bool user_exists();
+  bool group_exists();
+  void create_user();
+  void create_group();
+  void assign_group();
+};