Daniel Bedeleanu
ea49cd6e4a
- Create backend/services/image_storage.py with 4 core functions:
- sanitize_filename(): remove unsafe chars, limit to 255 chars, convert to lowercase
- get_unique_filename(): handle collisions with UUID suffix (format: {name}_{uuid8}_{variant}.jpg)
- ensure_image_directories(): create /images/ root and category subdirs on startup
- save_image(): save bytes to /images/{category}/{filename}, returns relative path
- Create comprehensive test suite (22 tests) covering all functionality
- Integrate ensure_image_directories() into FastAPI startup event
- Directory structure: /images/{category}/{filename}
- Collision handling: auto-suffix with UUID if filename exists
- All tests passing, pathlib.Path for safe operations
106 lines
2.7 KiB
C++
106 lines
2.7 KiB
C++
#ifndef GREENLET_THREAD_STATE_CREATOR_HPP
|
|
#define GREENLET_THREAD_STATE_CREATOR_HPP
|
|
|
|
#include <ctime>
|
|
#include <stdexcept>
|
|
|
|
#include "greenlet_internal.hpp"
|
|
#include "greenlet_refs.hpp"
|
|
#include "greenlet_thread_support.hpp"
|
|
|
|
#include "TThreadState.hpp"
|
|
|
|
namespace greenlet {
|
|
|
|
|
|
typedef void (*ThreadStateDestructor)(ThreadState* const);
|
|
|
|
// Only one of these, auto created per thread as a thread_local.
|
|
// This means we don't have to worry about atomic access to the
|
|
// internals, because by definition all access is happening on a
|
|
// single thread.
|
|
// Constructing the state constructs the MainGreenlet.
|
|
template<ThreadStateDestructor Destructor>
|
|
class ThreadStateCreator
|
|
{
|
|
private:
|
|
// Initialized to 1, and, if still 1, created on access.
|
|
// Set to 0 on destruction.
|
|
ThreadState* _state;
|
|
G_NO_COPIES_OF_CLS(ThreadStateCreator);
|
|
|
|
inline bool has_initialized_state() const noexcept
|
|
{
|
|
return this->_state != (ThreadState*)1;
|
|
}
|
|
|
|
inline bool has_state() const noexcept
|
|
{
|
|
return this->has_initialized_state() && this->_state != nullptr;
|
|
}
|
|
|
|
public:
|
|
|
|
ThreadStateCreator() :
|
|
_state((ThreadState*)1)
|
|
{
|
|
}
|
|
|
|
~ThreadStateCreator()
|
|
{
|
|
if (this->has_state()) {
|
|
Destructor(this->_state);
|
|
}
|
|
|
|
this->_state = nullptr;
|
|
}
|
|
|
|
inline ThreadState& state()
|
|
{
|
|
// The main greenlet will own this pointer when it is created,
|
|
// which will be right after this. The plan is to give every
|
|
// greenlet a pointer to the main greenlet for the thread it
|
|
// runs in; if we are doing something cross-thread, we need to
|
|
// access the pointer from the main greenlet. Deleting the
|
|
// thread, and hence the thread-local storage, will delete the
|
|
// state pointer in the main greenlet.
|
|
if (!this->has_initialized_state()) {
|
|
// XXX: Assuming allocation never fails
|
|
this->_state = new ThreadState;
|
|
// For non-standard threading, we need to store an object
|
|
// in the Python thread state dictionary so that it can be
|
|
// DECREF'd when the thread ends (ideally; the dict could
|
|
// last longer) and clean this object up.
|
|
}
|
|
if (!this->_state) {
|
|
throw std::runtime_error("Accessing state after destruction.");
|
|
}
|
|
return *this->_state;
|
|
}
|
|
|
|
operator ThreadState&()
|
|
{
|
|
return this->state();
|
|
}
|
|
|
|
operator ThreadState*()
|
|
{
|
|
return &this->state();
|
|
}
|
|
|
|
inline int tp_traverse(visitproc visit, void* arg)
|
|
{
|
|
if (this->has_state()) {
|
|
return this->_state->tp_traverse(visit, arg);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
}; // namespace greenlet
|
|
|
|
#endif
|