SemaphoreSetDistribuido::SemaphoreSetDistribuido(std::vector<unsigned short> & numeros_de_semaforo,
const std::string & directorio_de_trabajo, const std::string & nombre_app, const std::string & nombre_grupo,
char id, int cantidad_sems, bool create)
: nombre_recurso(nombre_grupo), cantidad_de_semaforos(cantidad_sems)
{
std::string prefijo_archivo;
prefijo_archivo = std::string(directorio_de_trabajo).append(PREFIJO_RECURSO).append(nombre_grupo);
char numero [5];
unsigned short valor;
if (cantidad_de_semaforos > 125) {
throw GenericError("Cannot allocate %d semaphores, max 125", cantidad_de_semaforos);
}
std::vector<unsigned short> valores(2 * cantidad_de_semaforos, 0);
create_if_not_exists(std::string(prefijo_archivo).append(POSTFIJO_LCK).c_str());
if (create) {
control = ControlTokens::get_instance(directorio_de_trabajo, true);
semaforos = new SemaphoreSet(valores, std::string(prefijo_archivo).append(POSTFIJO_LCK).c_str(), id, 0664);
} else {
control = ControlTokens::get_instance(directorio_de_trabajo);
semaforos = new SemaphoreSet(std::string(prefijo_archivo).append(POSTFIJO_LCK).c_str(), id, 0);
}
for (size_t i = 0 ; i < numeros_de_semaforo.size() ; i++) {
valor = numeros_de_semaforo [i];
sprintf(numero, "%d", valor);
lanzar_comunicacion(directorio_de_trabajo, nombre_app,
std::string(directorio_de_trabajo).append(PATH_LOCAL_BROKER_LIST_FILE).c_str(),
std::string(nombre_grupo).append(numero), id, 0, valor);
}
}
ApiCheckIn::ApiCheckIn(const char* directorio_de_trabajo, const char* config_file, int id_puesto_checkin,
int id_cinta_checkin, bool create)
: path_to_locks(directorio_de_trabajo), id_checkin(id_puesto_checkin)
{
create = !!create;
create_if_not_exists(std::string(directorio_de_trabajo).append(PATH_PUESTO_CHECKIN).c_str());
create_if_not_exists(std::string(directorio_de_trabajo).append(PATH_COLA_CONTROL_CHECKIN).c_str());
#if DEBUG_CINTA_CHECKIN == 0
vuelo_actual = new SharedObject<tVueloEnCheckin>(tVueloEnCheckin(id_cinta_checkin),
std::string(directorio_de_trabajo).append(PATH_PUESTO_CHECKIN).c_str(), id_puesto_checkin * cant_ipcs + 2);
#endif
cinta_checkin_out = new CintaCheckin(std::string("checkin").append(intToString(id_puesto_checkin)).c_str(),
std::string(directorio_de_trabajo).c_str(), id_puesto_checkin);
#if DEBUG_CINTA_CHECKIN == 0
sem_set = new SemaphoreSet(std::vector<unsigned short>(1, 1),
std::string(directorio_de_trabajo).append(PATH_PUESTO_CHECKIN).c_str(), id_puesto_checkin * cant_ipcs);
mutex_checkin = new Mutex(*sem_set, 0);
queue_manager = ApiConfiguracion::get_queue_manager(directorio_de_trabajo, config_file);
queue_pasajeros = (queue_manager)->get_queue(PATH_PUESTO_CHECKIN, 0);
queue_controlador = (queue_manager)->get_queue(PATH_COLA_CONTROL_CHECKIN, id_puesto_checkin, create);
ApiTorreDeControl api_torre(directorio_de_trabajo, config_file);
api_torre.liberar_puesto_checkin(id_puesto_checkin);
Log::info("lanzando controlador_puesto_checkin\n");
sprintf(id, "%d", id_puesto_checkin);
static char *args_controlador [] = {
(char*)"controlador_puesto_checkin", (char*)directorio_de_trabajo, (char*)config_file, id, archivo_equipaje_intercargo, NULL};
Process controlador_puesto_checkin("controlador_puesto_checkin", args_controlador);
#else
id_cinta_checkin = id_cinta_checkin;
config_file = config_file;
#endif
}
SemaphoreSetDistribuido::SemaphoreSetDistribuido(const std::string & directorio_de_trabajo,
const std::string & nombre_grupo, char id, int cantidad_semaforos)
: nombre_recurso(nombre_grupo), cantidad_de_semaforos(cantidad_semaforos)
{
std::string prefijo_archivo;
prefijo_archivo = std::string(directorio_de_trabajo).append(PREFIJO_RECURSO).append(nombre_grupo);
create_if_not_exists(std::string(prefijo_archivo).append(POSTFIJO_LCK).c_str());
control = ControlTokens::get_instance(directorio_de_trabajo);
semaforos = new SemaphoreSet(std::string(prefijo_archivo).append(POSTFIJO_LCK).c_str(), id, 0);
}
TEST_FIXTURE(blob_service_test_base_with_objects_to_delete, list_blobs_from_client_root)
{
auto root_container = m_client.get_root_container_reference();
root_container.create_if_not_exists();
auto prefix = get_random_container_name();
create_blobs(root_container, prefix, 1);
auto listing = list_all_blobs_from_client(prefix, azure::storage::blob_listing_details::none, 1, azure::storage::blob_request_options());
check_blob_list(listing);
}
void NProj::addExecutable(void) {
NDataStream tmp;
NDebug::print() << "Number of files: " << m_exe_files.count();
NDebug::print() << "Executable name: " << m_exe_name;
if (m_exe_name == "" && m_exe_files.count() > 0) {
throw NException("You provided source files for building the "
"executable but no executable name", NException::TOOLS);
}
else {
if (m_exe_name != "" && m_exe_files.count() == 0) {
throw NException("You provided an executable name but "
"no source files for building it",
NException::TOOLS);
}
else {
if (m_exe_name == "" && m_exe_files.count() == 0) {
return;
}
}
}
tmp = "# Project executable\n";
tmp = tmp + "ADD_EXECUTABLE(\n";
tmp = tmp + "\t" + m_exe_name + "\n";
for (nuint64 i = 0; i < m_exe_files.size(); i++) {
NDebug::print() << "Adding " << m_exe_files.at(i);
tmp = tmp + "\t" + m_exe_files.at(i) + "\n";
create_if_not_exists(m_exe_files.at(i), m_license ? NLGPL : "",
m_force);
}
tmp = tmp + ")\n\n";
m_output.write(tmp);
}
TEST_FIXTURE(container_test_base, container_name_unicode)
{
auto container = m_client.get_container_reference(_XPLATSTR("容器1"));
CHECK_STORAGE_EXCEPTION(container.exists(), error_invalid_characters_in_resource_name);
CHECK_STORAGE_EXCEPTION(container.create_if_not_exists(), error_invalid_characters_in_resource_name);
}
TEST_FIXTURE(file_directory_test_base, directory_list_files_and_directories)
{
m_directory.create_if_not_exists(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
azure::storage::list_file_and_diretory_result_iterator end_of_list;
for (auto iter = m_share.get_root_directory_reference().list_files_and_directories(); iter != end_of_list; ++iter)
{
CHECK_EQUAL(iter->is_directory(), true);
CHECK_EQUAL(iter->is_file(), false);
auto directory = iter->as_directory();
check_equal(directory, m_directory);
CHECK(directory.get_parent_share_reference().is_valid());
check_equal(m_share, directory.get_parent_share_reference());
CHECK(!directory.uri().primary_uri().is_empty());
CHECK(directory.metadata().empty());
CHECK(directory.properties().etag().empty());
CHECK(!directory.properties().last_modified().is_initialized());
}
// more complicated file structure.
const size_t size = 2;
std::vector<utility::string_t> directories;
std::vector<utility::string_t> files;
for (size_t i = 0; i < size; ++i)
{
directories.push_back(_XPLATSTR("directory") + get_random_string(10));
}
for (size_t i = 0; i < size; ++i)
{
files.push_back(_XPLATSTR("file") + get_random_string(10));
}
for (size_t i = 0; i < size; ++i)
{
auto directory = m_share.get_directory_reference(directories[i]);
directory.create_if_not_exists(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
for (size_t j = 0; j < size; ++j)
{
auto subdirectory = directory.get_subdirectory_reference(directories[j]);
subdirectory.create_if_not_exists(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
for (size_t k = 0; k < size; ++k)
{
auto file = subdirectory.get_file_reference(files[k]);
file.create_if_not_exists(512U, azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
}
}
for (size_t j = 0; j < size; ++j)
{
auto file = directory.get_file_reference(files[j]);
file.create_if_not_exists(512U, azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
}
auto file = m_share.get_root_directory_reference().get_file_reference(files[i]);
file.create_if_not_exists(512U, azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
}
auto direcotries_one = directories;
auto files_one = files;
for (auto iter = m_share.get_root_directory_reference().list_files_and_directories(); iter != end_of_list; ++iter)
{
if (iter->is_directory())
{
auto directory2 = iter->as_directory();
CHECK(directory2.get_parent_share_reference().is_valid());
check_equal(m_share, directory2.get_parent_share_reference());
CHECK(!directory2.uri().primary_uri().is_empty());
CHECK(directory2.metadata().empty());
CHECK(directory2.properties().etag().empty());
CHECK(!directory2.properties().last_modified().is_initialized());
auto found = false;
for (auto directory_name = direcotries_one.begin(); directory_name != direcotries_one.end(); directory_name++)
{
if (*directory_name == directory2.name())
{
direcotries_one.erase(directory_name);
found = true;
break;
}
}
auto direcotries_two = directories;
auto files_two = files;
for (auto iter2 = directory2.list_files_and_directories(); found && iter2 != end_of_list; ++iter2)
{
if (iter2->is_directory())
{
auto directory3 = iter2->as_directory();
CHECK(directory3.get_parent_share_reference().is_valid());
check_equal(m_share, directory3.get_parent_share_reference());
CHECK(!directory3.uri().primary_uri().is_empty());
CHECK(directory3.metadata().empty());
CHECK(directory3.properties().etag().empty());
CHECK(!directory3.properties().last_modified().is_initialized());
for (auto directory_name = direcotries_two.begin(); directory_name != direcotries_two.end(); directory_name++)
{
if (*directory_name == directory3.name())
{
direcotries_two.erase(directory_name);
break;
}
}
auto files_three = files;
for (auto iter3 = directory3.list_files_and_directories(); iter3 != end_of_list; ++iter3)
{
CHECK(iter3->is_file());
auto file = iter3->as_file();
CHECK(file.get_parent_share_reference().is_valid());
check_equal(m_share, file.get_parent_share_reference());
CHECK(!file.uri().primary_uri().is_empty());
CHECK(file.metadata().empty());
CHECK(file.properties().etag().empty());
CHECK(!file.properties().last_modified().is_initialized());
for (auto file_name = files_three.begin(); file_name != files_three.end(); file_name++)
{
if (*file_name == file.name())
{
files_three.erase(file_name);
break;
}
}
}
CHECK(files_three.empty());
}
else if (iter2->is_file())
{
auto file = iter2->as_file();
CHECK(file.get_parent_share_reference().is_valid());
check_equal(m_share, file.get_parent_share_reference());
CHECK(!file.uri().primary_uri().is_empty());
CHECK(file.metadata().empty());
CHECK(file.properties().etag().empty());
CHECK(!file.properties().last_modified().is_initialized());
for (auto file_name = files_two.begin(); file_name != files_two.end(); file_name++)
{
if (*file_name == file.name())
{
files_two.erase(file_name);
break;
}
}
}
}
CHECK(!found || direcotries_two.empty());
CHECK(!found || files_two.empty());
}
else if (iter->is_file())
{
auto file = iter->as_file();
CHECK(file.get_parent_share_reference().is_valid());
check_equal(m_share, file.get_parent_share_reference());
CHECK(!file.uri().primary_uri().is_empty());
CHECK(file.metadata().empty());
CHECK(file.properties().etag().empty());
CHECK(!file.properties().last_modified().is_initialized());
for (auto file_name = files_one.begin(); file_name != files_one.end(); file_name++)
{
if (*file_name == file.name())
{
files_one.erase(file_name);
break;
}
}
}
}
CHECK(direcotries_one.empty());
CHECK(files_one.empty());
}
