cloudelements-petit/lib/config.js

(function() {
  var _, async, createConfig, defaultConfig, fs, guid, maxTenantIndex, mkdirp, parseToml, path, pkg, readData, readQbData, tenantsType, toml, tweak, version, writeQbData;

  _ = require('lodash');

  async = require('async');

  fs = require('fs');

  path = require('path');

  mkdirp = require('mkdirp');

  toml = require('toml');

  pkg = require('../package.json');

  exports.version = version = function() {
    var ref;
    return {
      name: 'Ground2Cloud',
      version: pkg.version,
      display: (ref = pkg.displayVersion) != null ? ref : pkg.version
    };
  };

  defaultConfig = "[server]\nproxyPort = 8090\nsecureProxyPort = 8453\nbackPort = 3014\nlistenPort = 3016\nregistryfile = \"./registry\"\nregistryUrl = \"redis://localhost:6379\"\nstatsUrl = \"elastic://localhost:9200\"\napiPort = 8101\n\n[server.vitae]\nenvironment = \"local\"\n# environment = \"staging\"\nendpoint = \"http://REGID.localhost:8090\"\n# endpoint = \"https://REGID.g2c-staging.cloud-elements.com\"\n\n[client]\nhost = \"localhost\"\nport = 22\nbackPort = 3014\nusername = \"username\"\nlistenPort = 3015\nbindAddr = \"0.0.0.0\"\napiPort = 8100\n\n[client.vitae]\nbrand = \"ce\"\n\n[client.local]\nhost = \"localhost\"\nport = 8088\n";

  exports.readConfig = function(configPath, cb) {
    return createConfig(configPath, function(err, made, configPath) {
      if (err != null) {
        return cb(err, configPath);
      }
      return readData(configPath, cb);
    });
  };

  exports.pickConfig = function(configPath) {
    var configDirPath, home;
    if (configPath != null) {
      return configPath;
    }
    home = process.env.HOME || process.env.USERPROFILE;
    configDirPath = path.join(home, '.petit');
    return path.join(configDirPath, 'config.toml');
  };

  exports.createConfig = createConfig = function(configPath, cb) {
    var configDirPath, home;
    if (configPath == null) {
      home = process.env.HOME || process.env.USERPROFILE;
      configDirPath = path.join(home, '.petit');
      configPath = path.join(configDirPath, 'config.toml');
    } else {
      configDirPath = path.dirname(configPath);
    }
    return mkdirp(configDirPath, function(err) {
      if (err != null) {
        return cb(err, false, configPath);
      }
      return fs.exists(configPath, function(exists) {
        if (!exists) {
          return fs.writeFile(configPath, defaultConfig, {
            encoding: 'utf8'
          }, function(err) {
            return cb(err, true, configPath);
          });
        } else {
          return cb(null, false, configPath);
        }
      });
    });
  };

  exports.readRegistration = function(configPath, configData, cb) {
    var regs, tenPath;
    tenPath = path.join(path.dirname(configPath), 'tenants');
    regs = [];
    return mkdirp(tenPath, function(err) {
      if (err != null) {
        return cb(err);
      }
      return fs.readdir(tenPath, function(err, dirs) {
        if (err != null) {
          return cb(err);
        }
        return async.each(dirs, function(dir, cb) {
          var regfile, tendir;
          tendir = path.join(tenPath, dir);
          regfile = path.join(tendir, 'registration');
          return fs.exists(regfile, function(exists) {
            if (exists) {
              return fs.readFile(regfile, {
                encoding: 'utf8'
              }, function(err, fdata) {
                var e, obj;
                if (err != null) {
                  return cb(err);
                }
                try {
                  obj = JSON.parse(fdata);
                  obj.dir = tendir;
                  regs.push(obj);
                } catch (error) {
                  e = error;
                  return cb(e);
                }
                return cb(null);
              });
            } else {
              return cb(null);
            }
          });
        }, function(err) {
          return cb(err, regs);
        });
      });
    });
  };

  exports.readKey = function(configPath, configData, cb) {
    var keyPath;
    keyPath = path.join(path.dirname(configPath), 'key');
    return fs.exists(keyPath, function(exists) {
      if (exists) {
        return fs.readFile(keyPath, {
          encoding: 'utf8'
        }, cb);
      } else {
        return cb(null);
      }
    });
  };

  readData = function(configPath, cb) {
    return fs.readFile(configPath, {
      encoding: 'utf8'
    }, function(err, data) {
      if (err != null) {
        return cb(err, configPath);
      }
      return parseToml(configPath, data, function(err, configPath, parsed) {
        var runtimePath;
        runtimePath = path.join(path.dirname(configPath), 'runtime.json');
        return fs.exists(runtimePath, function(exists) {
          if (!exists) {
            return cb(err, configPath, parsed);
          }
          return fs.readFile(runtimePath, {
            encoding: 'utf8'
          }, function(err, data) {
            if (err != null) {
              return cb(err, configPath);
            }
            try {
              parsed.runtime = JSON.parse(data);
            } catch (error) {
              err = error;
              return cb(err, configPath);
            }
            return readQbData(configPath, parsed, cb);
          });
        });
      });
    });
  };

  readQbData = function(configPath, parsed, cb) {
    var qbPath;
    qbPath = path.join(path.dirname(configPath), 'qb.json');
    return fs.exists(qbPath, function(exists) {
      if (!exists) {
        return cb(err, configPath, parsed);
      }
      return fs.readFile(qbPath, {
        encoding: 'utf8'
      }, function(err, data) {
        if (err != null) {
          return cb(err, configPath);
        }
        try {
          if (parsed.client == null) {
            parsed.client = {};
          }
          parsed.client.qbmonitor = JSON.parse(data);
        } catch (error) {
          err = error;
          return cb(err, configPath);
        }
        return cb(null, configPath, parsed);
      });
    });
  };

  exports.writeQbData = writeQbData = function(clconfigData, cb) {
    var qbPath, qbdata;
    qbPath = path.join(path.dirname(clconfigData.configPath), 'qb.json');
    qbdata = JSON.stringify(clconfigData.qbmonitor, null, 2);
    return fs.writeFile(qbPath, qbdata, {
      encoding: 'utf8'
    }, cb);
  };

  parseToml = function(configPath, data, cb) {
    var e, parsed, ref, ref1;
    try {
      parsed = tweak(configPath, toml.parse(data));
      parsed.configPath = configPath;
      if ((ref = parsed.server) != null) {
        ref.configPath = configPath;
      }
      if ((ref1 = parsed.client) != null) {
        ref1.configPath = configPath;
      }
    } catch (error) {
      e = error;
      return cb(e, configPath);
    }
    return cb(null, configPath, parsed);
  };

  tweak = function(configPath, data) {
    var dirname;
    dirname = path.dirname(configPath);
    if (_.isString(data)) {
      if (_.startsWith(data, './')) {
        return path.join(dirname, data.substr(2));
      } else if (_.startsWith(data, '../')) {
        return path.join(path.dirname(dirname), data.substr(3));
      } else {
        return data;
      }
    } else if (_.isObject(data)) {
      return _.forOwn(data, function(v, k) {
        return data[k] = tweak(configPath, v);
      });
    } else {
      return data;
    }
  };

  tenantsType = function(cfgData, reg, cb) {
    var tenPath;
    tenPath = path.join(path.dirname(cfgData.configPath), 'tenants');
    return mkdirp(tenPath, function(err) {
      if (err != null) {
        return cb(err);
      }
      return fs.readdir(tenPath, function(err, dirs) {
        if (err != null) {
          return cb(err);
        }
        return async.filter(dirs, function(dir, cb) {
          return fs.readdir(path.join(tenPath, dir), function(err, files) {
            if (err != null) {
              return cb(err);
            }
            return cb(null, (files.indexOf('registration') === -1) === reg);
          });
        }, function(err, dirs) {
          return cb(err, tenPath, dirs);
        });
      });
    });
  };

  exports.unregisteredTenants = function(cfgData, cb) {
    return tenantsType(cfgData, true, cb);
  };

  exports.registeredTenants = function(cfgData, cb) {
    return tenantsType(cfgData, false, cb);
  };

  exports.allTenants = function(cfgData, cb) {
    var tenPath;
    tenPath = path.join(path.dirname(cfgData.configPath), 'tenants');
    return mkdirp(tenPath, function(err) {
      if (err != null) {
        return cb(err);
      }
      return fs.readdir(tenPath, function(err, dirs) {
        if (err != null) {
          return cb(err);
        }
        return async.map(dirs, function(dir, cb) {
          var regFile, tendir;
          tendir = path.join(tenPath, dir);
          regFile = path.join(tendir, 'registration');
          return fs.exists(regFile, function(exists) {
            if (exists) {
              return fs.readFile(regFile, {
                encoding: 'utf8'
              }, function(err, data) {
                var e, obj;
                if (err != null) {
                  return cb(err);
                }
                try {
                  obj = JSON.parse(data);
                } catch (error) {
                  e = error;
                  return cb(e);
                }
                return cb(null, {
                  dir: tendir,
                  name: dir,
                  registered: true,
                  registeredId: obj.id,
                  registeredPort: obj.port
                });
              });
            } else {
              return cb(null, {
                dir: tendir,
                name: dir,
                registered: false
              });
            }
          });
        }, function(err, tens) {
          return cb(err, tenPath, tens);
        });
      });
    });
  };

  exports.tenantConfig = function(tname, cfgData, cb) {
    var tenPath;
    tenPath = path.join(path.dirname(cfgData.configPath), 'tenants');
    return mkdirp(tenPath, function(err) {
      var tCfgPath, tendir;
      if (err != null) {
        return cb(err);
      }
      tendir = path.join(tenPath, tname);
      tCfgPath = path.join(tendir, 'config.toml');
      return fs.exists(tendir, function(exists) {
        if (exists) {
          return fs.exists(tCfgPath, function(exists) {
            if (exists) {
              return fs.readFile(tCfgPath, {
                encoding: 'utf8'
              }, function(err, data) {
                var e, obj;
                try {
                  obj = toml.parse(data);
                } catch (error) {
                  e = error;
                  return cb(e);
                }
                return cb(null, tCfgPath, obj);
              });
            } else {
              return cb(null, tCfgPath, {});
            }
          });
        } else {
          return cb("No such tenant " + tname);
        }
      });
    });
  };

  maxTenantIndex = function(cfgData, cb) {
    var max, tenPath;
    tenPath = path.join(path.dirname(cfgData.configPath), 'tenants');
    max = 0;
    return mkdirp(tenPath, function(err) {
      if (err != null) {
        return cb(err);
      }
      return fs.readdir(tenPath, function(err, dirs) {
        if (err != null) {
          return cb(err);
        }
        return async.each(dirs, function(dir, cb) {
          var cfgFile, tendir;
          tendir = path.join(tenPath, dir);
          cfgFile = path.join(tendir, 'config.toml');
          return fs.exists(cfgFile, function(exists) {
            if (exists) {
              return fs.readFile(cfgFile, {
                encoding: 'utf8'
              }, function(err, data) {
                var e, obj;
                if (err != null) {
                  return cb(err);
                }
                try {
                  obj = toml.parse(data);
                } catch (error) {
                  e = error;
                  return cb(e);
                }
                if (_.isNumber(obj.index)) {
                  max = Math.max(max, obj.index);
                }
                return cb(null);
              });
            } else {
              return cb(null);
            }
          });
        }, function(err) {
          return cb(err, max);
        });
      });
    });
  };

  exports.lease = function(cfgData, cb) {
    var newten, tenPath;
    tenPath = path.join(path.dirname(cfgData.configPath), 'tenants');
    newten = path.join(tenPath, guid());
    return mkdirp(newten, function(err) {
      if (err != null) {
        return cb(err);
      }
      return maxTenantIndex(cfgData, function(err, max) {
        var cfg, cfgFile, ref, ref1, ref2, ref3;
        if (err != null) {
          return cb(err);
        }
        cfgFile = path.join(newten, 'config.toml');
        cfg = "name = \"lease\"\nindex = " + (max + 1) + "\n\n[local]\nhost = \"" + ((ref = (ref1 = cfgData.local) != null ? ref1.host : void 0) != null ? ref : 'localhost') + "\"\nport = " + ((ref2 = (ref3 = cfgData.local) != null ? ref3.port : void 0) != null ? ref2 : 8080) + "\n";
        return fs.writeFile(cfgFile, cfg, {
          encoding: 'utf8'
        }, function(err) {
          return cb(err, newten);
        });
      });
    });
  };

  exports.guid = guid = function() {
    var s4;
    s4 = function() {
      return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
    };
    return s4() + s4() + s4() + s4();
  };

}).call(this);