BaseLog* BazaarLog::generateLog(const std::string& dir) {
//does directory have a .bzr ?
std::string bzrdir = dir + std::string("/.bzr");
struct stat dirinfo;
int stat_rc = stat(bzrdir.c_str(), &dirinfo);
if(stat_rc!=0 || !(dirinfo.st_mode & S_IFDIR)) {
return 0;
}
std::string command = getLogCommand();
// do we have this client installed
requireExecutable("bzr");
createTempLog();
if(temp_file.size()==0) return 0;
char cmd_buff[2048];
sprintf(cmd_buff, "%s %s > %s", command.c_str(), dir.c_str(), temp_file.c_str());
int command_rc = systemCommand(cmd_buff);
if(command_rc != 0) {
return 0;
}
BaseLog* seeklog = new SeekLog(temp_file);
return seeklog;
}
void KangarooChannel::baudRate(int32_t baudRate)
{
uint8_t index;
switch (baudRate)
{
case 9600: default: index = 0; break;
case 19200: index = 1; break;
case 38400: index = 2; break;
case 115200: index = 3; break;
}
int32_t values[1] = { index };
systemCommand(KANGAROO_SYS_SET_BAUD_RATE, false, values, 1);
}
bool
VMType::createConfigUsingScript(const char* configfile)
{
vmprintf(D_FULLDEBUG, "Inside VMType::createConfigUsingScript\n");
if( !configfile || m_scriptname.IsEmpty() ) {
return false;
}
// Set temporary environments for script program
StringList name_list;
const char *name;
ExprTree* expr = NULL;
m_classAd.ResetExpr();
while( m_classAd.NextExpr(name, expr) ) {
if( !strncasecmp( name, "JobVM", strlen("JobVM") ) ||
!strncasecmp( name, "VMPARAM", strlen("VMPARAM") )) {
name_list.append(name);
SetEnv(name, ExprTreeToString(expr));
}
}
ArgList systemcmd;
if( m_prog_for_script.IsEmpty() == false ) {
systemcmd.AppendArg(m_prog_for_script);
}
systemcmd.AppendArg(m_scriptname);
systemcmd.AppendArg("createconfig");
systemcmd.AppendArg(configfile);
int result = systemCommand(systemcmd, m_file_owner);
// UnSet temporary environments for script program
const char *tmp_name = NULL;
name_list.rewind();
while( (tmp_name = name_list.next()) != NULL ) {
UnsetEnv(tmp_name);
}
if( result != 0 ) {
vmprintf(D_ALWAYS, "Failed to create Configuration file('%s') using "
"script program('%s')\n", configfile,
m_scriptname.Value());
return false;
}
return true;
}
BaseLog* SVNCommitLog::generateLog(const std::string& dir) {
//get working directory
char cwd_buff[1024];
if(getcwd(cwd_buff, 1024) != cwd_buff) {
return 0;
}
//does directory have a .svn ?
std::string gitdir = dir + std::string("/.svn");
struct stat dirinfo;
int stat_rc = stat(gitdir.c_str(), &dirinfo);
if(stat_rc!=0 || !(dirinfo.st_mode & S_IFDIR)) {
return 0;
}
// do we have this client installed
requireExecutable("svn");
std::string command = getLogCommand();
//create temp file
createTempLog();
if(temp_file.size()==0) return 0;
if(chdir(dir.c_str()) != 0) {
return 0;
}
char cmd_buff[2048];
snprintf(cmd_buff, 2048, "%s > %s", command.c_str(), temp_file.c_str());
int command_rc = systemCommand(cmd_buff);
chdir(cwd_buff);
if(command_rc != 0) {
return 0;
}
BaseLog* seeklog = new SeekLog(temp_file);
return seeklog;
}
BaseLog* GitCommitLog::generateLog(const std::string& dir) {
//get working directory
char cwd_buff[1024];
if(getcwd(cwd_buff, 1024) != cwd_buff) {
return 0;
}
//does directory have a .git ?
std::string gitdir = dir + std::string("/.git");
struct stat dirinfo;
int stat_rc = stat(gitdir.c_str(), &dirinfo);
if(stat_rc!=0 || !(dirinfo.st_mode & S_IFDIR)) {
return 0;
}
// do we have this client installed
requireExecutable("git");
std::string command = getLogCommand();
//create temp file
createTempLog();
if(temp_file.size()==0) return 0;
if(chdir(dir.c_str()) != 0) {
return 0;
}
char cmd_buff[2048];
sprintf(cmd_buff, "%s > %s", command.c_str(), temp_file.c_str());
int command_rc = systemCommand(cmd_buff);
if(command_rc != 0) {
chdir(cwd_buff);
return 0;
}
// check for new-enough Git version
// if %aN does not appear to be supported try %an
std::ifstream in(temp_file.c_str());
char firstBytes[9];
in.read(firstBytes, 8);
in.close();
firstBytes[8] = '\0';
if(!strcmp(firstBytes, "user:%aN")) {
char *pos = strstr(cmd_buff, "%aN");
pos[2] = 'n';
command_rc = systemCommand(cmd_buff);
}
//change back to original directoy
chdir(cwd_buff);
if(command_rc != 0) {
return 0;
}
BaseLog* seeklog = new SeekLog(temp_file);
return seeklog;
}
KangarooError KangarooChannel::serialTimeout(int32_t milliseconds)
{
int32_t values[] = { milliseconds < 0 ? -1 : (milliseconds * 2 + 124) / 125 }; // The command takes time in 16ths of a second. Round up.
return systemCommand(KANGAROO_SYS_SET_SERIAL_TIMEOUT, true, values, 1);
}
KangarooError KangarooChannel::powerDownAll()
{
int32_t values[0];
return systemCommand(KANGAROO_SYS_POWER_DOWN_ALL, true, values, 0);
}
bool GitCommitLog::parseCommit(RCommit& commit) {
std::string line;
char filesizeBuf[256];
commit.username = "";
while(logf->getNextLine(line) && line.size()) {
if(line.find("commit_id:") == 0) {
commit.commit_id = line.substr(10);
if(!logf->getNextLine(line)) return false;
//username follows user prefix
commit.username = line.substr(5);
if(!logf->getNextLine(line)) return false;
commit.timestamp = atol(line.c_str());
//this isnt a commit we are parsing, abort
if(commit.timestamp == 0) return false;
continue;
}
//should see username before files
if(commit.username.empty()) return false;
size_t tab = line.find('\t');
//incorrect log format
if(tab == std::string::npos || tab == 0 || tab == line.size()-1) continue;
std::string status = line.substr(tab - 1, 1);
std::string file = line.substr(tab + 1);
if(file.empty()) continue;
//check for and remove double quotes
if(file.find('"') == 0 && file.rfind('"') == file.size()-1) {
if(file.size()<=2) continue;
file = file.substr(1,file.size()-2);
}
std::string size_temp_file = temp_file + "_filesize";
memset(filesizeBuf, 0, sizeof(char) * 256);
snprintf(filesizeBuf, sizeof(char) * 256, GitGetFileSizeCommand.c_str(), commit.commit_id.c_str(), file.c_str(), size_temp_file.c_str());
systemCommand(filesizeBuf);
std::ifstream ifs ( size_temp_file );
std::string filesize_str;
ifs >> filesize_str;
size_t filesize = 0;
if(!filesize_str.empty()) {
filesize = std::stoi(filesize_str);
}
commit.addFile(file, status, filesize);
}
//check we at least got a username
if(commit.username.empty()) return false;
return true;
}
// I really need a good way to determine the type of a classad
// attribute. Right now I just try all four possibilities, which is a
// horrible mess...
bool VirshType::CreateVirshConfigFile(const char* /*filename*/)
{
vmprintf(D_FULLDEBUG, "In VirshType::CreateVirshConfigFile\n");
// std::string name;
char * tmp = param("LIBVIRT_XML_SCRIPT");
if(tmp == NULL)
{
vmprintf(D_ALWAYS, "LIBVIRT_XML_SCRIPT not defined\n");
return false;
}
// This probably needs some work...
ArgList args;
args.AppendArg(tmp);
free(tmp);
// We might want to have specific debugging output enabled in the
// helper script; however, it is not clear where that output should
// go. This gives us a way to do so even in cases where the script
// is unable to read from condor_config (why would this ever
// happen?)
tmp = param("LIBVIRT_XML_SCRIPT_ARGS");
if(tmp != NULL)
{
MyString errormsg;
args.AppendArgsV1RawOrV2Quoted(tmp,&errormsg);
free(tmp);
}
StringList input_strings, output_strings, error_strings;
MyString classad_string;
m_classAd.sPrint(classad_string);
classad_string += VMPARAM_XEN_BOOTLOADER;
classad_string += " = \"";
classad_string += m_xen_bootloader;
classad_string += "\"\n";
if(classad_string.find(VMPARAM_XEN_INITRD) < 1)
{
classad_string += VMPARAM_XEN_INITRD;
classad_string += " = \"";
classad_string += m_xen_initrd_file;
classad_string += "\"\n";
}
if(!m_vm_bridge_interface.empty())
{
classad_string += VMPARAM_BRIDGE_INTERFACE;
classad_string += " = \"";
classad_string += m_vm_bridge_interface.c_str();
classad_string += "\"\n";
}
if(classad_string.find(ATTR_JOB_VM_NETWORKING_TYPE) < 1)
{
classad_string += ATTR_JOB_VM_NETWORKING_TYPE;
classad_string += " = \"";
classad_string += m_vm_networking_type.Value();
classad_string += "\"\n";
}
input_strings.append(classad_string.Value());
tmp = input_strings.print_to_string();
vmprintf(D_FULLDEBUG, "LIBVIRT_XML_SCRIPT_ARGS input_strings= %s\n", tmp);
free(tmp);
int ret = systemCommand(args, PRIV_ROOT, &output_strings, &input_strings, &error_strings, false);
error_strings.rewind();
if(ret != 0)
{
vmprintf(D_ALWAYS, "XML helper script could not be executed\n");
output_strings.rewind();
// If there is any output from the helper, write it to the debug
// log. Presumably, this is separate from the script's own
// debug log.
while((tmp = error_strings.next()) != NULL)
{
vmprintf(D_FULLDEBUG, "Helper stderr output: %s\n", tmp);
}
return false;
}
error_strings.rewind();
while((tmp = error_strings.next()) != NULL)
{
vmprintf(D_ALWAYS, "Helper stderr output: %s\n", tmp);
}
output_strings.rewind();
while((tmp = output_strings.next()) != NULL)
{
m_xml += tmp;
}
return true;
}
