bool Host::migrateVmFrom(class Host *hfrom){
xmlrpc_c::clientSimple client;
xmlrpc_c::value result_rpc;
string const service = "one.vm.migrate";
class VirtualMachine *vm = hfrom->getMigrateableVm();
if (vm == NULL || this->state != Host::NODE_ON)
return false;
cout << "Migrating VM " << vm->id << " from " << hfrom->id << " to " << this->id << endl;
client.call(serverUrl, service, "siib", &result_rpc, rpc_id.c_str(),
vm->id, this->id, true); // use live migration
xmlrpc_c::value_array result_array(result_rpc);
vector<xmlrpc_c::value> const result(result_array.vectorValueValue());
xmlrpc_c::value_boolean status = static_cast<xmlrpc_c::value>(result[0]);
if ( static_cast<bool>(status))
return true;
else{ //an error occurred
xmlrpc_c::value_string msg = static_cast<xmlrpc_c::value_string>(result[1]);
cout << static_cast<string>(msg) << endl;
}
return false;
}
int Script::ConvertResultToJsonValue(const IECommandExecutor& executor,
Json::Value* value) {
int status_code = SUCCESS;
if (this->ResultIsString()) {
std::string string_value = "";
if (this->result_.bstrVal) {
string_value = CW2A(this->result_.bstrVal, CP_UTF8);
}
*value = string_value;
} else if (this->ResultIsInteger()) {
*value = this->result_.lVal;
} else if (this->ResultIsDouble()) {
*value = this->result_.dblVal;
} else if (this->ResultIsBoolean()) {
*value = this->result_.boolVal == VARIANT_TRUE;
} else if (this->ResultIsEmpty()) {
*value = Json::Value::null;
} else if (this->result_.vt == VT_NULL) {
*value = Json::Value::null;
} else if (this->ResultIsIDispatch()) {
if (this->ResultIsArray() || this->ResultIsElementCollection()) {
Json::Value result_array(Json::arrayValue);
long length = 0;
status_code = this->GetArrayLength(&length);
for (long i = 0; i < length; ++i) {
Json::Value array_item_result;
int array_item_status = this->GetArrayItem(executor,
i,
&array_item_result);
result_array[i] = array_item_result;
}
*value = result_array;
} else if (this->ResultIsObject()) {
Json::Value result_object;
std::wstring property_name_list = L"";
status_code = this->GetPropertyNameList(&property_name_list);
std::vector<std::wstring> property_names;
size_t end_position(0);
size_t start_position(0);
while (true) {
std::wstring property_name = L"";
end_position = property_name_list.find_first_of(L",", start_position);
if(end_position == std::wstring::npos) {
property_names.push_back(property_name_list.substr(start_position,
property_name_list.size() - start_position));
break;
} else {
property_names.push_back(property_name_list.substr(start_position,
end_position - start_position));
start_position = end_position + 1;
}
}
for (size_t i = 0; i < property_names.size(); ++i) {
Json::Value property_value_result;
int property_value_status = this->GetPropertyValue(executor,
property_names[i],
&property_value_result);
std::string name(CW2A(property_names[i].c_str(), CP_UTF8));
result_object[name] = property_value_result;
}
*value = result_object;
} else {
IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor);
IHTMLElement* node = reinterpret_cast<IHTMLElement*>(this->result_.pdispVal);
ElementHandle element_wrapper;
mutable_executor.AddManagedElement(node, &element_wrapper);
*value = element_wrapper->ConvertToJson();
}
} else {
status_code = EUNKNOWNSCRIPTRESULT;
}
return status_code;
}
static void DrawFuncShading(CFX_DIBitmap* pBitmap,
CFX_Matrix* pObject2Bitmap,
CPDF_Dictionary* pDict,
CPDF_Function** pFuncs,
int nFuncs,
CPDF_ColorSpace* pCS,
int alpha) {
ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
CPDF_Array* pDomain = pDict->GetArray("Domain");
FX_FLOAT xmin = 0, ymin = 0, xmax = 1.0f, ymax = 1.0f;
if (pDomain) {
xmin = pDomain->GetNumber(0);
xmax = pDomain->GetNumber(1);
ymin = pDomain->GetNumber(2);
ymax = pDomain->GetNumber(3);
}
CFX_Matrix mtDomain2Target = pDict->GetMatrix("Matrix");
CFX_Matrix matrix, reverse_matrix;
matrix.SetReverse(*pObject2Bitmap);
reverse_matrix.SetReverse(mtDomain2Target);
matrix.Concat(reverse_matrix);
int width = pBitmap->GetWidth();
int height = pBitmap->GetHeight();
int pitch = pBitmap->GetPitch();
int total_results = 0;
for (int j = 0; j < nFuncs; j++) {
if (pFuncs[j]) {
total_results += pFuncs[j]->CountOutputs();
}
}
if (pCS->CountComponents() > total_results) {
total_results = pCS->CountComponents();
}
CFX_FixedBufGrow<FX_FLOAT, 16> result_array(total_results);
FX_FLOAT* pResults = result_array;
FXSYS_memset(pResults, 0, total_results * sizeof(FX_FLOAT));
for (int row = 0; row < height; row++) {
FX_DWORD* dib_buf = (FX_DWORD*)(pBitmap->GetBuffer() + row * pitch);
for (int column = 0; column < width; column++) {
FX_FLOAT x = (FX_FLOAT)column, y = (FX_FLOAT)row;
matrix.Transform(x, y);
if (x < xmin || x > xmax || y < ymin || y > ymax) {
continue;
}
FX_FLOAT input[2];
int offset = 0;
input[0] = x;
input[1] = y;
for (int j = 0; j < nFuncs; j++) {
if (pFuncs[j]) {
int nresults;
if (pFuncs[j]->Call(input, 2, pResults + offset, nresults)) {
offset += nresults;
}
}
}
FX_FLOAT R = 0.0f, G = 0.0f, B = 0.0f;
pCS->GetRGB(pResults, R, G, B);
dib_buf[column] = FXARGB_TODIB(FXARGB_MAKE(
alpha, (int32_t)(R * 255), (int32_t)(G * 255), (int32_t)(B * 255)));
}
}
}
static void DrawAxialShading(CFX_DIBitmap* pBitmap,
CFX_Matrix* pObject2Bitmap,
CPDF_Dictionary* pDict,
CPDF_Function** pFuncs,
int nFuncs,
CPDF_ColorSpace* pCS,
int alpha) {
ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
CPDF_Array* pCoords = pDict->GetArray("Coords");
if (!pCoords) {
return;
}
FX_FLOAT start_x = pCoords->GetNumber(0);
FX_FLOAT start_y = pCoords->GetNumber(1);
FX_FLOAT end_x = pCoords->GetNumber(2);
FX_FLOAT end_y = pCoords->GetNumber(3);
FX_FLOAT t_min = 0, t_max = 1.0f;
CPDF_Array* pArray = pDict->GetArray("Domain");
if (pArray) {
t_min = pArray->GetNumber(0);
t_max = pArray->GetNumber(1);
}
FX_BOOL bStartExtend = FALSE, bEndExtend = FALSE;
pArray = pDict->GetArray("Extend");
if (pArray) {
bStartExtend = pArray->GetInteger(0);
bEndExtend = pArray->GetInteger(1);
}
int width = pBitmap->GetWidth();
int height = pBitmap->GetHeight();
FX_FLOAT x_span = end_x - start_x;
FX_FLOAT y_span = end_y - start_y;
FX_FLOAT axis_len_square =
FXSYS_Mul(x_span, x_span) + FXSYS_Mul(y_span, y_span);
CFX_Matrix matrix;
matrix.SetReverse(*pObject2Bitmap);
int total_results = 0;
for (int j = 0; j < nFuncs; j++) {
if (pFuncs[j]) {
total_results += pFuncs[j]->CountOutputs();
}
}
if (pCS->CountComponents() > total_results) {
total_results = pCS->CountComponents();
}
CFX_FixedBufGrow<FX_FLOAT, 16> result_array(total_results);
FX_FLOAT* pResults = result_array;
FXSYS_memset(pResults, 0, total_results * sizeof(FX_FLOAT));
FX_DWORD rgb_array[SHADING_STEPS];
for (int i = 0; i < SHADING_STEPS; i++) {
FX_FLOAT input = (t_max - t_min) * i / SHADING_STEPS + t_min;
int offset = 0;
for (int j = 0; j < nFuncs; j++) {
if (pFuncs[j]) {
int nresults = 0;
if (pFuncs[j]->Call(&input, 1, pResults + offset, nresults)) {
offset += nresults;
}
}
}
FX_FLOAT R = 0.0f, G = 0.0f, B = 0.0f;
pCS->GetRGB(pResults, R, G, B);
rgb_array[i] =
FXARGB_TODIB(FXARGB_MAKE(alpha, FXSYS_round(R * 255),
FXSYS_round(G * 255), FXSYS_round(B * 255)));
}
int pitch = pBitmap->GetPitch();
for (int row = 0; row < height; row++) {
FX_DWORD* dib_buf = (FX_DWORD*)(pBitmap->GetBuffer() + row * pitch);
for (int column = 0; column < width; column++) {
FX_FLOAT x = (FX_FLOAT)column, y = (FX_FLOAT)row;
matrix.Transform(x, y);
FX_FLOAT scale = FXSYS_Div(
FXSYS_Mul(x - start_x, x_span) + FXSYS_Mul(y - start_y, y_span),
axis_len_square);
int index = (int32_t)(scale * (SHADING_STEPS - 1));
if (index < 0) {
if (!bStartExtend) {
continue;
}
index = 0;
} else if (index >= SHADING_STEPS) {
if (!bEndExtend) {
continue;
}
index = SHADING_STEPS - 1;
}
dib_buf[column] = rgb_array[index];
}
}
}
static void DrawRadialShading(CFX_DIBitmap* pBitmap,
CFX_Matrix* pObject2Bitmap,
CPDF_Dictionary* pDict,
CPDF_Function** pFuncs,
int nFuncs,
CPDF_ColorSpace* pCS,
int alpha) {
ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
CPDF_Array* pCoords = pDict->GetArray("Coords");
if (!pCoords) {
return;
}
FX_FLOAT start_x = pCoords->GetNumber(0);
FX_FLOAT start_y = pCoords->GetNumber(1);
FX_FLOAT start_r = pCoords->GetNumber(2);
FX_FLOAT end_x = pCoords->GetNumber(3);
FX_FLOAT end_y = pCoords->GetNumber(4);
FX_FLOAT end_r = pCoords->GetNumber(5);
CFX_Matrix matrix;
matrix.SetReverse(*pObject2Bitmap);
FX_FLOAT t_min = 0, t_max = 1.0f;
CPDF_Array* pArray = pDict->GetArray("Domain");
if (pArray) {
t_min = pArray->GetNumber(0);
t_max = pArray->GetNumber(1);
}
FX_BOOL bStartExtend = FALSE, bEndExtend = FALSE;
pArray = pDict->GetArray("Extend");
if (pArray) {
bStartExtend = pArray->GetInteger(0);
bEndExtend = pArray->GetInteger(1);
}
int total_results = 0;
for (int j = 0; j < nFuncs; j++) {
if (pFuncs[j]) {
total_results += pFuncs[j]->CountOutputs();
}
}
if (pCS->CountComponents() > total_results) {
total_results = pCS->CountComponents();
}
CFX_FixedBufGrow<FX_FLOAT, 16> result_array(total_results);
FX_FLOAT* pResults = result_array;
FXSYS_memset(pResults, 0, total_results * sizeof(FX_FLOAT));
FX_DWORD rgb_array[SHADING_STEPS];
for (int i = 0; i < SHADING_STEPS; i++) {
FX_FLOAT input = (t_max - t_min) * i / SHADING_STEPS + t_min;
int offset = 0;
for (int j = 0; j < nFuncs; j++) {
if (pFuncs[j]) {
int nresults;
if (pFuncs[j]->Call(&input, 1, pResults + offset, nresults)) {
offset += nresults;
}
}
}
FX_FLOAT R = 0.0f, G = 0.0f, B = 0.0f;
pCS->GetRGB(pResults, R, G, B);
rgb_array[i] =
FXARGB_TODIB(FXARGB_MAKE(alpha, FXSYS_round(R * 255),
FXSYS_round(G * 255), FXSYS_round(B * 255)));
}
FX_FLOAT a = FXSYS_Mul(start_x - end_x, start_x - end_x) +
FXSYS_Mul(start_y - end_y, start_y - end_y) -
FXSYS_Mul(start_r - end_r, start_r - end_r);
int width = pBitmap->GetWidth();
int height = pBitmap->GetHeight();
int pitch = pBitmap->GetPitch();
FX_BOOL bDecreasing = FALSE;
if (start_r > end_r) {
int length = (int)FXSYS_sqrt((FXSYS_Mul(start_x - end_x, start_x - end_x) +
FXSYS_Mul(start_y - end_y, start_y - end_y)));
if (length < start_r - end_r) {
bDecreasing = TRUE;
}
}
for (int row = 0; row < height; row++) {
FX_DWORD* dib_buf = (FX_DWORD*)(pBitmap->GetBuffer() + row * pitch);
for (int column = 0; column < width; column++) {
FX_FLOAT x = (FX_FLOAT)column, y = (FX_FLOAT)row;
matrix.Transform(x, y);
FX_FLOAT b = -2 * (FXSYS_Mul(x - start_x, end_x - start_x) +
FXSYS_Mul(y - start_y, end_y - start_y) +
FXSYS_Mul(start_r, end_r - start_r));
FX_FLOAT c = FXSYS_Mul(x - start_x, x - start_x) +
FXSYS_Mul(y - start_y, y - start_y) -
FXSYS_Mul(start_r, start_r);
FX_FLOAT s;
if (a == 0) {
s = FXSYS_Div(-c, b);
} else {
FX_FLOAT b2_4ac = FXSYS_Mul(b, b) - 4 * FXSYS_Mul(a, c);
if (b2_4ac < 0) {
continue;
}
FX_FLOAT root = FXSYS_sqrt(b2_4ac);
FX_FLOAT s1, s2;
if (a > 0) {
s1 = FXSYS_Div(-b - root, 2 * a);
s2 = FXSYS_Div(-b + root, 2 * a);
} else {
s2 = FXSYS_Div(-b - root, 2 * a);
s1 = FXSYS_Div(-b + root, 2 * a);
}
if (bDecreasing) {
if (s1 >= 0 || bStartExtend) {
s = s1;
} else {
s = s2;
}
} else {
if (s2 <= 1.0f || bEndExtend) {
s = s2;
} else {
s = s1;
}
}
if ((start_r + s * (end_r - start_r)) < 0) {
continue;
}
}
int index = (int32_t)(s * (SHADING_STEPS - 1));
if (index < 0) {
if (!bStartExtend) {
continue;
}
index = 0;
}
if (index >= SHADING_STEPS) {
if (!bEndExtend) {
continue;
}
index = SHADING_STEPS - 1;
}
dib_buf[column] = rgb_array[index];
}
}
}
int VariantUtilities::ConvertVariantToJsonValue(const IECommandExecutor& executor,
VARIANT variant_value,
Json::Value* value) {
int status_code = WD_SUCCESS;
if (VariantIsString(variant_value)) {
std::string string_value = "";
if (variant_value.bstrVal) {
std::wstring bstr_value = variant_value.bstrVal;
string_value = StringUtilities::ToString(bstr_value);
}
*value = string_value;
} else if (VariantIsInteger(variant_value)) {
*value = variant_value.lVal;
} else if (VariantIsDouble(variant_value)) {
*value = variant_value.dblVal;
} else if (VariantIsBoolean(variant_value)) {
*value = variant_value.boolVal == VARIANT_TRUE;
} else if (VariantIsEmpty(variant_value)) {
*value = Json::Value::null;
} else if (variant_value.vt == VT_NULL) {
*value = Json::Value::null;
} else if (VariantIsIDispatch(variant_value)) {
if (VariantIsArray(variant_value) ||
VariantIsElementCollection(variant_value)) {
Json::Value result_array(Json::arrayValue);
long length = 0;
status_code = GetArrayLength(variant_value.pdispVal, &length);
for (long i = 0; i < length; ++i) {
Json::Value array_item_result;
int array_item_status = GetArrayItem(executor,
variant_value.pdispVal,
i,
&array_item_result);
result_array[i] = array_item_result;
}
*value = result_array;
} else if (VariantIsObject(variant_value)) {
Json::Value result_object;
std::vector<std::wstring> property_names;
status_code = GetPropertyNameList(variant_value.pdispVal,
&property_names);
for (size_t i = 0; i < property_names.size(); ++i) {
CComVariant property_value_variant;
GetVariantObjectPropertyValue(variant_value.pdispVal,
property_names[i],
&property_value_variant);
Json::Value property_value;
ConvertVariantToJsonValue(executor,
property_value_variant,
&property_value);
std::string name = StringUtilities::ToString(property_names[i]);
result_object[name] = property_value;
}
*value = result_object;
} else {
LOG(INFO) << "Unknown type of dispatch is found in result, assuming IHTMLElement";
IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor);
CComPtr<IHTMLElement> node;
variant_value.pdispVal->QueryInterface<IHTMLElement>(&node);
ElementHandle element_wrapper;
mutable_executor.AddManagedElement(node, &element_wrapper);
*value = element_wrapper->ConvertToJson();
}
} else {
LOG(WARN) << "Unknown type of result is found";
status_code = EUNKNOWNSCRIPTRESULT;
}
return status_code;
}
