NS_IMETHODIMP
WriteStumbleOnThread::Run()
{
  MOZ_ASSERT(!NS_IsMainThread());

  bool b = sIsAlreadyRunning.exchange(true);
  if (b) {
    return NS_OK;
  }

  STUMBLER_DBG("In WriteStumbleOnThread\n");

  UploadFileStatus status = GetUploadFileStatus();

  if (UploadFileStatus::NoFile != status) {
    if (UploadFileStatus::ExistsAndReadyToUpload == status) {
      Upload();
    }
  } else {
    Partition partition = GetWritePosition();
    if (partition == Partition::Unknown) {
      STUMBLER_ERR("GetWritePosition failed, skip once");
    } else {
      WriteJSON(partition);
    }
  }

  sIsAlreadyRunning = false;
  return NS_OK;
}
Exemple #2
0
int main(int argc, char* argv[])
{
	char *fname = NULL;
	char *oname = NULL;
	char *ename = NULL;
	bool sax = false;
	bool model = true;
	bool full = false;
	bool expat = false;

	if (argc == 1) {
		WriteHelp();
		return 0;
	}

	for (int i = 1; i < argc; i++) {
		if ((argv[i][0] == '-')
		 || (argv[i][0] == '/')) {  // switch
			switch(argv[i][1]) {
				case 'o':  // output file
					oname = argv[++i];
					break;
				case 'e':  // error file
					ename = argv[++i];
					break;
				case 's':
					sax = true;
					break;
				case 'n':
					model = false;
					break;
				case 'f':
					full = true;
					break;
				case 'x':
					expat = true;
					break;
				case 'h':
				case '?':
					WriteHelp(false);
					return 0;
				case 'a':
					WriteHelp(true);
					return 0;
				default:
					fputs("Unrecognized option; options are case-sensitive.\n\n", stdout);
					WriteHelp(false);
					return 0;
			}
		}
		else  // source filename
			fname = argv[i];
	}

	if (oname) {
		FILE *tmp = fopen(oname, "w");
		if (tmp)
			ofile = tmp;
	}

	Parser = new MxlParser();

	Parser->SetOptions(sax, model, full);
	if (expat)
		Parser->SetExpatCallbacks(ename);
	else
		Parser->SetCallbacks(ename);
	element *result = Parser->ParseFile(fname, NULL);

	// send result to stdout in JSON format
	if (result) {
		fputs("\n\n", ofile);
		WriteJSON(result, 1);
		fputs("\n\n", ofile);
	}

	return 0;
}
Exemple #3
0
void WriteJSON(element *el, long lev)
{
	long tabs = (lev - 1) * 2;
	long i = 0;
	pair *attr = NULL;
	cont *citem = NULL;
	
	PutTabs(tabs);
	fputs("[ \"", ofile);
	Put32StrJSON(el->name, el->namelen);
	fputs("\",", ofile);

	if (!el->attrcnt)
		fputs(" {}, ", ofile);
	else if (el->attrcnt == 1) {
		fputs(" { \"", ofile);
		attr = el->attrs[0];
		Put32StrJSON(attr->name, attr->namelen);
		fputs("\": \"", ofile);
		Put32StrJSON(attr->val, attr->vallen);
		fputs("\" }, ", ofile);
	}
	else {
		fputs("\n", ofile);
		PutTabs(tabs + 1);
		fputc('{', ofile);
		for (i = 0; i < el->attrcnt; i++) {
			if (!i) 
				fputc('\t', ofile);
			else
				PutTabs(tabs + 2);
			fputc('"', ofile);
			attr = el->attrs[i];
			Put32StrJSON(attr->name, attr->namelen);
			fputs("\": \"", ofile);
			Put32StrJSON(attr->val, attr->vallen);
			fputc('"', ofile);
			if (i < (el->attrcnt - 1))
				fputc(',', ofile);
			fputs("\n", ofile);
		}
		PutTabs(tabs + 1);
		fputs("}, ", ofile);
	}

	if (!el->contcnt)
		fputs(" []", ofile);
	else if ((el->contcnt == 1)
	 && (citem = el->content[0])->cnt) {
		fputs("[ \"", ofile);
		Put32StrJSON((unl *) citem->it, citem->cnt);
		fputs("\" ]", ofile);
	}
	else {
		fputs("\n", ofile);
		PutTabs(tabs + 1);
		fputs("[", ofile);
		for (i = 0; i < el->contcnt; i++) {
			citem = el->content[i];
			if (citem->cnt) {  // text
				if (!i) 
					fputc('\t', ofile);
				else
					PutTabs(tabs + 2);
				fputc('"', ofile);
				Put32StrJSON((unl *) citem->it, citem->cnt);
				fputc('"', ofile);
			}
			else { // element
				if (!i)
					fputs("\n", ofile);
				WriteJSON((element *) citem->it, lev + 1);
			}
			if (i < (el->contcnt - 1))
				fputc(',', ofile);
			fputs("\n", ofile);
		}
		PutTabs(tabs + 1);
		fputs("]", ofile);
	}
	fputs("\n", ofile);
	PutTabs(tabs);
	fputs("]", ofile);
}
void
WriteStumbleOnThread::WriteJSON(Partition aPart)
{
  MOZ_ASSERT(!NS_IsMainThread());

  nsCOMPtr<nsIFile> tmpFile;
  nsresult rv;
  rv = nsDumpUtils::OpenTempFile(kOutputFileNameInProgress, getter_AddRefs(tmpFile),
                                 kOutputDirName, nsDumpUtils::CREATE);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    STUMBLER_ERR("Open a file for stumble failed");
    return;
  }

  nsRefPtr<nsGZFileWriter> gzWriter = new nsGZFileWriter(nsGZFileWriter::Append);
  rv = gzWriter->Init(tmpFile);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    STUMBLER_ERR("gzWriter init failed");
    return;
  }

  /*
   The json format is like below.
   {items:[
   {item},
   {item},
   {item}
   ]}
   */

  // Need to add "]}" after the last item
  if (aPart == Partition::End) {
    gzWriter->Write("]}");
    rv = gzWriter->Finish();
    if (NS_WARN_IF(NS_FAILED(rv))) {
      STUMBLER_ERR("gzWriter finish failed");
    }

    nsCOMPtr<nsIFile> targetFile;
    nsresult rv = nsDumpUtils::OpenTempFile(kOutputFileNameCompleted, getter_AddRefs(targetFile),
                                            kOutputDirName, nsDumpUtils::CREATE);
    nsAutoString targetFilename;
    rv = targetFile->GetLeafName(targetFilename);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      STUMBLER_ERR("Get Filename failed");
      return;
    }
    rv = targetFile->Remove(true);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      STUMBLER_ERR("Remove File failed");
      return;
    }
    // Rename tmpfile
    rv = tmpFile->MoveTo(/* directory */ nullptr, targetFilename);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      STUMBLER_ERR("Rename File failed");
      return;
    }
    return;
  }

  // Need to add "{items:[" before the first item
  if (aPart == Partition::Begining) {
    gzWriter->Write("{\"items\":[{");
  } else if (aPart == Partition::Middle) {
    gzWriter->Write(",{");
  }
  gzWriter->Write(mDesc.get());
  //  one item is end with '}' (e.g. {item})
  gzWriter->Write("}");
  rv = gzWriter->Finish();
  if (NS_WARN_IF(NS_FAILED(rv))) {
    STUMBLER_ERR("gzWriter finish failed");
  }

  // check if it is the end of this file
  int64_t fileSize = 0;
  rv = tmpFile->GetFileSize(&fileSize);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    STUMBLER_ERR("GetFileSize failed");
    return;
  }
  if (fileSize >= MAXFILESIZE_KB) {
    WriteJSON(Partition::End);
    return;
  }
}