Slic3r::SL1Host Class Reference

#include <src/slic3r/Utils/OctoPrint.hpp>

Inheritance diagram for Slic3r::SL1Host:

Collaboration diagram for Slic3r::SL1Host:

Public Types
typedef Http::ProgressFn	ProgressFn
typedef std::function< void(wxString)>	ErrorFn
typedef std::function< void(wxString, wxString)>	InfoFn

Public Member Functions
	SL1Host (DynamicPrintConfig *config)
	~SL1Host () override=default
const char *	get_name () const override
wxString	get_test_ok_msg () const override
wxString	get_test_failed_msg (wxString &msg) const override
PrintHostPostUploadActions	get_post_upload_actions () const override
bool	get_storage (wxArrayString &storage_path, wxArrayString &storage_name) const override
bool	upload (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const override
bool	has_auto_discovery () const override
bool	can_test () const override
std::string	get_host () const override
const std::string &	get_apikey () const
const std::string &	get_cafile () const
virtual bool	supports_multiple_printers () const
virtual bool	get_groups (wxArrayString &) const
virtual bool	get_printers (wxArrayString &) const

Static Public Member Functions
static PrintHost *	get_print_host (DynamicPrintConfig *config)

Protected Member Functions
bool	validate_version_text (const boost::optional< std::string > &version_text) const override
bool	test (wxString &curl_msg) const override
bool	upload_inner_with_host (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const override
void	set_auth (Http &http) const override
virtual void	set_http_post_header_args (Http &http, PrintHostPostUploadAction post_action) const
std::string	make_url (const std::string &path) const
virtual wxString	format_error (const std::string &body, const std::string &error, unsigned status) const

Protected Attributes
AuthorizationType	m_authorization_type
std::string	m_username
std::string	m_password
std::string	m_host
std::string	m_apikey
std::string	m_cafile
bool	m_ssl_revoke_best_effort

Private Member Functions
bool	test_with_method_check (wxString &curl_msg, bool &use_put) const
bool	put_inner (PrintHostUpload upload_data, std::string url, const std::string &name, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const
bool	post_inner (PrintHostUpload upload_data, std::string url, const std::string &name, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const

Private Attributes
bool	m_show_after_message

Detailed Description

Member Typedef Documentation

ErrorFn

typedef std::function<void(wxString )> Slic3r::PrintHost::ErrorFn

inherited

InfoFn

typedef std::function<void(wxString , wxString )> Slic3r::PrintHost::InfoFn

inherited

ProgressFn

typedef Http::ProgressFn Slic3r::PrintHost::ProgressFn

inherited

Constructor & Destructor Documentation

SL1Host()

Slic3r::SL1Host::SL1Host

(

DynamicPrintConfig *

config

)

    : PrusaLink(config)
{
}

~SL1Host()

Slic3r::SL1Host::~SL1Host ( )

overridedefault

Member Function Documentation

can_test()

bool Slic3r::OctoPrint::can_test ( ) const

inlineoverridevirtualinherited

Implements Slic3r::PrintHost.

{ return true; }

format_error()

wxString Slic3r::PrintHost::format_error ( const std::string &  body, const std::string &  error, unsigned  status  ) const

protectedvirtualinherited

{
    if (status != 0) {
        auto wxbody = wxString::FromUTF8(body.data());
        return wxString::Format("HTTP %u: %s", status, wxbody);
    } else {
        return wxString::FromUTF8(error.data());
    }
}

References error.

Referenced by Slic3r::Duet::connect(), Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), Slic3r::Duet::start_print(), Slic3r::AstroBox::test(), Slic3r::FlashAir::test(), Slic3r::Moonraker::test(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), Slic3r::Repetier::test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::AstroBox::upload(), Slic3r::Duet::upload(), Slic3r::FlashAir::upload(), Slic3r::MKS::upload(), Slic3r::Moonraker::upload(), Slic3r::Repetier::upload(), and Slic3r::OctoPrint::upload_inner_with_host().

Here is the caller graph for this function:

get_apikey()

const std::string & Slic3r::OctoPrint::get_apikey ( ) const

inlineinherited

{ return m_apikey; }

References Slic3r::OctoPrint::m_apikey.

Referenced by Slic3r::PrusaLink::set_auth().

Here is the caller graph for this function:

get_cafile()

const std::string & Slic3r::OctoPrint::get_cafile ( ) const

inlineinherited

{ return m_cafile; }

References Slic3r::OctoPrint::m_cafile.

Referenced by Slic3r::PrusaLink::set_auth().

Here is the caller graph for this function:

get_groups()

virtual bool Slic3r::PrintHost::get_groups ( wxArrayString &  ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

get_host()

std::string Slic3r::OctoPrint::get_host ( ) const

inlineoverridevirtualinherited

Implements Slic3r::PrintHost.

{ return m_host; }

References Slic3r::OctoPrint::m_host.

get_name()

const char * Slic3r::SL1Host::get_name ( ) const

overridevirtual

Reimplemented from Slic3r::PrusaLink.

{ return "SL1Host"; }

get_post_upload_actions()

PrintHostPostUploadActions Slic3r::SL1Host::get_post_upload_actions ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::PrusaLink.

{ return {}; }

get_print_host()

PrintHost * Slic3r::PrintHost::get_print_host ( DynamicPrintConfig *  config )

staticinherited

{
    PrinterTechnology tech = ptFFF;
 
    {
        const auto opt = config->option<ConfigOptionEnum<PrinterTechnology>>("printer_technology");
        if (opt != nullptr) {
            tech = opt->value;
        }
    }
 
    if (tech == ptFFF) {
        const auto opt = config->option<ConfigOptionEnum<PrintHostType>>("host_type");
        const auto host_type = opt != nullptr ? opt->value : htOctoPrint;
 
        switch (host_type) {
            case htOctoPrint: return new OctoPrint(config);
            case htDuet:      return new Duet(config);
            case htFlashAir:  return new FlashAir(config);
            case htAstroBox:  return new AstroBox(config);
            case htRepetier:  return new Repetier(config);
            case htPrusaLink: return new PrusaLink(config);
            case htPrusaConnect: return new PrusaConnect(config);
            case htMKS:       return new MKS(config);
            case htMoonraker: return new Moonraker(config);
            default:          return nullptr;
        }
    } else {
        return new SL1Host(config);
    }
}

References Slic3r::htAstroBox, Slic3r::htDuet, Slic3r::htFlashAir, Slic3r::htMKS, Slic3r::htMoonraker, Slic3r::htOctoPrint, Slic3r::htPrusaConnect, Slic3r::htPrusaLink, Slic3r::htRepetier, Slic3r::ConfigBase::option(), Slic3r::ptFFF, and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::PhysicalPrinterDialog::update_printers(), and Slic3r::GUI::PhysicalPrinterDialog::update_printhost_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

get_printers()

virtual bool Slic3r::PrintHost::get_printers ( wxArrayString &  ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

get_storage()

bool Slic3r::PrusaLink::get_storage ( wxArrayString &  storage_path, wxArrayString &  storage_name  ) const

overridevirtualinherited

Reimplemented from Slic3r::PrintHost.

{
    const char* name = get_name();
 
    bool res = true;
    auto url = make_url("api/v1/storage");
    wxString error_msg;
 
    struct StorageInfo {
        wxString path;
        wxString name;
        bool read_only = false;
        long long free_space = -1;
    };
    std::vector<StorageInfo> storage;
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Get storage at: %2%") % name % url;
 
    wxString wlang = GUI::wxGetApp().current_language_code();
    std::string lang = GUI::format(wlang.SubString(0, 1));
 
    auto http = Http::get(std::move(url));
    set_auth(http);
    http.header("Accept-Language", lang);
    http.on_error([&](std::string body, std::string error, unsigned status) {
        BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error getting storage: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
        error_msg = L"\n\n" + boost::nowide::widen(error);
        res = false;
        // If status is 0, the communication with the printer has failed completely (most likely a timeout), if the status is <= 400, it is an error returned by the pritner.
        // If 0, we can show error to the user now, as we know the communication has failed. (res = true will do the trick.)
        // if not 0, we must not show error, as not all printers support api/v1/storage endpoint.
        // So we must be extra careful here, or we might be showing errors on perfectly fine communication.
        if (status == 0)
            res = true;
       
    })
    .on_complete([&](std::string body, unsigned) {
        BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got storage: %2%") % name % body;
        try
        {
            std::stringstream ss(body);
            pt::ptree ptree;
            pt::read_json(ss, ptree);
            
            // what if there is more structure added in the future? Enumerate all elements? 
            if (ptree.front().first != "storage_list") {
                res = false;
                return;
            }
            // each storage has own subtree of storage_list
            for (const auto& section : ptree.front().second) {
                const auto name = section.second.get_optional<std::string>("name");
                const auto path = section.second.get_optional<std::string>("path");
                const auto space = section.second.get_optional<std::string>("free_space");
                const auto read_only = section.second.get_optional<bool>("read_only");
                const auto ro = section.second.get_optional<bool>("ro"); // In PrusaLink 0.7.0RC2 "read_only" value is stored under "ro".
                const auto available = section.second.get_optional<bool>("available");
                if (path && (!available || *available)) {
                    StorageInfo si;
                    si.path = boost::nowide::widen(*path);
                    si.name = name ? boost::nowide::widen(*name) : wxString();
                    // If read_only is missing, assume it is NOT read only.
                    // si.read_only = read_only ? *read_only : false; // version without "ro"
                    si.read_only = (read_only ? *read_only : (ro ? *ro : false));
                    si.free_space = space ? std::stoll(*space) : 1;  // If free_space is missing, assume there is free space.
                    storage.emplace_back(std::move(si));
                }
            }
        }
        catch (const std::exception&)
        {
            res = false;
        }
    })
#ifdef WIN32
    .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
 
#endif // WIN32
    .perform_sync();
 
    for (const auto& si : storage) {
        if (!si.read_only && si.free_space > 0) {
            storage_path.push_back(si.path);
            storage_name.push_back(si.name);
        }
    }
 
    if (res && storage_path.empty()) {
        if (!storage.empty()) { // otherwise error_msg is already filled 
            error_msg = L"\n\n" + _L("Storages found") + L": \n";
            for (const auto& si : storage) {
                error_msg += GUI::format_wxstr(si.read_only ?
                                                                // TRN %1% = storage path
                                                                _L("%1% : read only") : 
                                                                // TRN %1% = storage path
                                                                _L("%1% : no free space"), si.path) + L"\n";
            }
        }
        // TRN %1% = host
        std::string message = GUI::format(_L("Upload has failed. There is no suitable storage found at %1%."), m_host) + GUI::into_u8(error_msg);
        BOOST_LOG_TRIVIAL(error) << message;
        throw Slic3r::IOError(message);
    }
 
    return res;
}

References _L, error, Slic3r::GUI::format(), Slic3r::GUI::format_wxstr(), Slic3r::Http::get(), Slic3r::PrusaLink::get_name(), Slic3r::GUI::into_u8(), L, Slic3r::OctoPrint::m_host, Slic3r::OctoPrint::m_ssl_revoke_best_effort, Slic3r::OctoPrint::make_url(), Slic3r::PrusaLink::set_auth(), and boost::nowide::widen().

Here is the call graph for this function:

get_test_failed_msg()

wxString Slic3r::SL1Host::get_test_failed_msg ( wxString &  msg ) const

overridevirtual

Reimplemented from Slic3r::PrusaLink.

{
    return GUI::format_wxstr("%s: %s", _L("Could not connect to Prusa SLA"), msg);
}

References _L, and Slic3r::GUI::format_wxstr().

Here is the call graph for this function:

get_test_ok_msg()

wxString Slic3r::SL1Host::get_test_ok_msg ( ) const

overridevirtual

Reimplemented from Slic3r::PrusaLink.

{
    return _(L("Connection to Prusa SL1 / SL1S works correctly."));
}

References _, and L.

has_auto_discovery()

bool Slic3r::OctoPrint::has_auto_discovery ( ) const

inlineoverridevirtualinherited

Implements Slic3r::PrintHost.

{ return true; }

make_url()

std::string Slic3r::OctoPrint::make_url ( const std::string &  path ) const

protectedinherited

{
    if (m_host.find("http://") == 0 || m_host.find("https://") == 0) {
        if (m_host.back() == '/') {
            return (boost::format("%1%%2%") % m_host % path).str();
        } else {
            return (boost::format("%1%/%2%") % m_host % path).str();
        }
    } else {
        return (boost::format("http://%1%/%2%") % m_host % path).str();
    }
}

References Slic3r::OctoPrint::m_host.

Referenced by Slic3r::PrusaLink::get_storage(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::OctoPrint::upload_inner_with_host(), and Slic3r::PrusaLink::upload_inner_with_host().

Here is the caller graph for this function:

post_inner()

bool Slic3r::PrusaLink::post_inner ( PrintHostUpload  upload_data, std::string  url, const std::string &  name, ProgressFn  prorgess_fn, ErrorFn  error_fn, InfoFn  info_fn  ) const

privateinherited

{
    info_fn(L"set_complete_off", wxString());
    bool res = true;
    const auto upload_filename = upload_data.upload_path.filename();
    const auto upload_parent_path = upload_data.upload_path.parent_path();
 
    Http http = Http::post(std::move(url));
#ifdef WIN32
    // "Host" header is necessary here. We have resolved IP address and subsituted it into "url" variable.
    // And when creating Http object above, libcurl automatically includes "Host" header from address it got.
    // Thus "Host" is set to the resolved IP instead of host filled by user. We need to change it back.
    // Not changing the host would work on the most cases (where there is 1 service on 1 hostname) but would break when f.e. reverse proxy is used (issue #9734).
    // https://www.rfc-editor.org/rfc/rfc7230#section-5.4
    std::string host = get_host_from_url(m_host);
    http.header("Host", host);
#endif // _WIN32
    set_auth(http);
    set_http_post_header_args(http, upload_data.post_action);
    http.form_add("path", upload_parent_path.string())      // XXX: slashes on windows ???
        .form_add_file("file", upload_data.source_path.string(), upload_filename.string())
        .on_complete([&](std::string body, unsigned status) {
            if (m_show_after_message) {
                // PrusaConnect message
                wxString widebody = wxString::FromUTF8(body);
                BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: File uploaded: HTTP %2%: %3%") % name % status % widebody;
                std::string message = m_show_after_message ? (boost::format("%1%") % widebody).str() : std::string();
                if (status == 202)
                    info_fn(L"complete_with_warning", message);
                else 
                    info_fn(L"complete", message);
            } else {
                // PrusaLink
                BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: File uploaded: HTTP %2%") % name % status;
                info_fn(L"complete", wxString());
            }
           
           
        })
        .on_error([&](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error uploading file: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
            error_fn(format_error(body, error, status));
            res = false;
        })
        .on_progress([&](Http::Progress progress, bool& cancel) {
            prorgess_fn(std::move(progress), cancel);
            if (cancel) {
                // Upload was canceled
                BOOST_LOG_TRIVIAL(info) << "Octoprint: Upload canceled";
                res = false;
            }
        })
#ifdef WIN32
        .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
#endif
        .perform_sync();
 
    return res;
}

References error, Slic3r::Http::form_add(), Slic3r::Http::form_add_file(), Slic3r::PrintHost::format_error(), Slic3r::Http::header(), L, Slic3r::OctoPrint::m_host, Slic3r::PrusaLink::m_show_after_message, Slic3r::OctoPrint::m_ssl_revoke_best_effort, Slic3r::Http::on_complete(), Slic3r::Http::perform_sync(), Slic3r::Http::post(), Slic3r::PrintHostUpload::post_action, Slic3r::PrusaLink::set_auth(), Slic3r::PrusaLink::set_http_post_header_args(), Slic3r::PrintHostUpload::source_path, and Slic3r::PrintHostUpload::upload_path.

Referenced by Slic3r::PrusaLink::upload_inner_with_host().

Here is the call graph for this function:

Here is the caller graph for this function:

put_inner()

bool Slic3r::PrusaLink::put_inner ( PrintHostUpload  upload_data, std::string  url, const std::string &  name, ProgressFn  prorgess_fn, ErrorFn  error_fn, InfoFn  info_fn  ) const

privateinherited

{
    info_fn(L"set_complete_off", wxString());
 
    bool res = true;
    // Percent escape all filenames in on path and add it to the url. This is different from POST.
    url += "/" + escape_path_by_element(upload_data.upload_path);
    Http http = Http::put(std::move(url));
#ifdef WIN32
    // "Host" header is necessary here. We have resolved IP address and subsituted it into "url" variable.
    // And when creating Http object above, libcurl automatically includes "Host" header from address it got.
    // Thus "Host" is set to the resolved IP instead of host filled by user. We need to change it back.
    // Not changing the host would work on the most cases (where there is 1 service on 1 hostname) but would break when f.e. reverse proxy is used (issue #9734).
    // https://www.rfc-editor.org/rfc/rfc7230#section-5.4
    std::string host = get_host_from_url(m_host);
    http.header("Host", host);
#endif // _WIN32
    set_auth(http);
    // This is ugly, but works. There was an error at PrusaLink side that accepts any string at Print-After-Upload as true, thus False was also triggering print after upload.
    if (upload_data.post_action == PrintHostPostUploadAction::StartPrint)
        http.header("Print-After-Upload", "?1");
    http.set_put_body(upload_data.source_path)
        .header("Content-Type", "text/x.gcode")
        .header("Overwrite", "?1")
        .on_complete([&](std::string body, unsigned status) {
            wxString widebody = wxString::FromUTF8(body);
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: File uploaded: HTTP %2%: %3%") % name % status % widebody;
            std::string message = m_show_after_message ? (boost::format("%1%") % widebody).str() : std::string();
            info_fn(L"complete", message);
        })
        .on_error([&](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error uploading file: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
            error_fn(format_error(body, error, status));
            res = false;
        })
        .on_progress([&](Http::Progress progress, bool& cancel) {
            prorgess_fn(std::move(progress), cancel);
            if (cancel) {
                // Upload was canceled
                BOOST_LOG_TRIVIAL(info) << "Octoprint: Upload canceled";
                res = false;
            }
        })
#ifdef WIN32
        .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
#endif
        .perform_sync();
 
    return res;
}

References error, Slic3r::PrintHost::format_error(), Slic3r::Http::header(), L, Slic3r::OctoPrint::m_host, Slic3r::PrusaLink::m_show_after_message, Slic3r::OctoPrint::m_ssl_revoke_best_effort, Slic3r::Http::on_complete(), Slic3r::Http::perform_sync(), Slic3r::PrintHostUpload::post_action, Slic3r::Http::put(), Slic3r::PrusaLink::set_auth(), Slic3r::Http::set_put_body(), Slic3r::PrintHostUpload::source_path, Slic3r::StartPrint, and Slic3r::PrintHostUpload::upload_path.

Referenced by Slic3r::PrusaLink::upload_inner_with_host().

Here is the call graph for this function:

Here is the caller graph for this function:

set_auth()

void Slic3r::PrusaLink::set_auth ( Http &  http ) const

overrideprotectedvirtualinherited

Reimplemented from Slic3r::OctoPrint.

{
    switch (m_authorization_type) {
    case atKeyPassword:
        http.header("X-Api-Key", get_apikey());
        break;
    case atUserPassword:
        http.auth_digest(m_username, m_password);
        break;
    }
 
    if (!get_cafile().empty()) {
        http.ca_file(get_cafile());
    }
}

References Slic3r::atKeyPassword, Slic3r::atUserPassword, Slic3r::Http::auth_digest(), Slic3r::Http::ca_file(), Slic3r::empty(), Slic3r::OctoPrint::get_apikey(), Slic3r::OctoPrint::get_cafile(), Slic3r::Http::header(), Slic3r::PrusaLink::m_authorization_type, Slic3r::PrusaLink::m_password, and Slic3r::PrusaLink::m_username.

Referenced by Slic3r::PrusaLink::get_storage(), Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), Slic3r::PrusaLink::test(), and Slic3r::PrusaLink::test_with_method_check().

Here is the call graph for this function:

Here is the caller graph for this function:

set_http_post_header_args()

void Slic3r::PrusaLink::set_http_post_header_args ( Http &  http, PrintHostPostUploadAction  post_action  ) const

protectedvirtualinherited

Reimplemented in Slic3r::PrusaConnect.

{
    http.form_add("print", post_action == PrintHostPostUploadAction::StartPrint ? "true" : "false");
}

References Slic3r::Http::form_add(), and Slic3r::StartPrint.

Referenced by Slic3r::PrusaLink::post_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

supports_multiple_printers()

virtual bool Slic3r::PrintHost::supports_multiple_printers ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

test()

bool Slic3r::PrusaLink::test ( wxString &  curl_msg ) const

overrideprotectedvirtualinherited

Reimplemented from Slic3r::OctoPrint.

{
    // Since the request is performed synchronously here,
    // it is ok to refer to `msg` from within the closure
    const char* name = get_name();
 
    bool res = true;
    auto url = make_url("api/version");
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Get version at: %2%") % name % url;
 
    auto http = Http::get(std::move(url));
    set_auth(http);
    http.on_error([&](std::string body, std::string error, unsigned status) {
        BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error getting version: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
        res = false;
        msg = format_error(body, error, status);
        })
        .on_complete([&, this](std::string body, unsigned) {
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got version: %2%") % name % body;
 
            try {
                std::stringstream ss(body);
                pt::ptree ptree;
                pt::read_json(ss, ptree);
 
                if (!ptree.get_optional<std::string>("api")) {
                    res = false;
                    return;
                }
 
                const auto text = ptree.get_optional<std::string>("text");
                res = validate_version_text(text);
                if (!res) {
                    msg = GUI::format_wxstr(_L("Mismatched type of print host: %s"), (text ? *text : "OctoPrint"));
                }
            }
            catch (const std::exception&) {
                res = false;
                msg = "Could not parse server response";
            }
        })
#ifdef WIN32
        .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
        .on_ip_resolve([&](std::string address) {
            // Workaround for Windows 10/11 mDNS resolve issue, where two mDNS resolves in succession fail.
            // Remember resolved address to be reused at successive REST API call.
            msg = GUI::from_u8(address);
        })
#endif // WIN32
        .perform_sync();
 
     return res;
}

References _L, error, Slic3r::PrintHost::format_error(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_u8(), Slic3r::Http::get(), Slic3r::PrusaLink::get_name(), Slic3r::OctoPrint::m_ssl_revoke_best_effort, Slic3r::OctoPrint::make_url(), Slic3r::PrusaLink::set_auth(), and Slic3r::PrusaLink::validate_version_text().

Here is the call graph for this function:

test_with_method_check()

bool Slic3r::PrusaLink::test_with_method_check ( wxString &  curl_msg, bool &  use_put  ) const

privateinherited

{
    // Since the request is performed synchronously here,
    // it is ok to refer to `msg` from within the closure
 
    const char* name = get_name();
 
    bool res = true;
    auto url = make_url("api/version");
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Get version at: %2%") % name % url;
    // Here we do not have to add custom "Host" header - the url contains host filled by user and libCurl will set the header by itself.
    auto http = Http::get(std::move(url));
    set_auth(http);
    http.on_error([&](std::string body, std::string error, unsigned status) {
        BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error getting version: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
        res = false;
        msg = format_error(body, error, status);
    })
    .on_complete([&, this](std::string body, unsigned) {
        BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got version: %2%") % name % body;
 
        try {
            std::stringstream ss(body);
            pt::ptree ptree;
            pt::read_json(ss, ptree);
 
            if (!ptree.get_optional<std::string>("api")) {
                res = false;
                return;
            }
 
            const auto text = ptree.get_optional<std::string>("text");
            res = validate_version_text(text);
            if (!res) {
                msg = GUI::format_wxstr(_L("Mismatched type of print host: %s"), (text ? *text : "OctoPrint"));
                use_put = false;
                return;
            }
 
            //  find capabilities subtree and read upload-by-put
            for (const auto& section : ptree) {
                if (section.first == "capabilities") {
                    const auto put_upload = section.second.get_optional<bool>("upload-by-put");
                    if (put_upload)
                        use_put = *put_upload;
                    break;
                }
            }
 
        }
        catch (const std::exception&) {
            res = false;
            msg = "Could not parse server response";
        }
    })
#ifdef WIN32
    .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
    .on_ip_resolve([&](std::string address) {
        // Workaround for Windows 10/11 mDNS resolve issue, where two mDNS resolves in succession fail.
        // Remember resolved address to be reused at successive REST API call.
        msg = GUI::from_u8(address);
    })
#endif // WIN32
    .perform_sync();
 
    return res;
}

References _L, error, Slic3r::PrintHost::format_error(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_u8(), Slic3r::Http::get(), Slic3r::PrusaLink::get_name(), Slic3r::OctoPrint::m_ssl_revoke_best_effort, Slic3r::OctoPrint::make_url(), Slic3r::PrusaLink::set_auth(), and Slic3r::PrusaLink::validate_version_text().

Referenced by Slic3r::PrusaLink::upload_inner_with_host().

Here is the call graph for this function:

Here is the caller graph for this function:

upload()

bool Slic3r::OctoPrint::upload ( PrintHostUpload  upload_data, ProgressFn  prorgess_fn, ErrorFn  error_fn, InfoFn  info_fn  ) const

overridevirtualinherited

Implements Slic3r::PrintHost.

{
#ifndef WIN32
    return upload_inner_with_host(std::move(upload_data), prorgess_fn, error_fn, info_fn);
#else
    std::string host = get_host_from_url(m_host);
 
    // decide what to do based on m_host - resolve hostname or upload to ip
    std::vector<boost::asio::ip::address> resolved_addr;
    boost::system::error_code ec;
    boost::asio::ip::address host_ip = boost::asio::ip::make_address(host, ec);
    if (!ec) {
        resolved_addr.push_back(host_ip);
    } else if ( GUI::get_app_config()->get_bool("allow_ip_resolve") && boost::algorithm::ends_with(host, ".local")){
        Bonjour("octoprint")
            .set_hostname(host)
            .set_retries(5) // number of rounds of queries send
            .set_timeout(1) // after each timeout, if there is any answer, the resolving will stop
            .on_resolve([&ra = resolved_addr](const std::vector<BonjourReply>& replies) {
                for (const auto & rpl : replies) {
                    boost::asio::ip::address ip(rpl.ip);
                    ra.emplace_back(ip);
                    BOOST_LOG_TRIVIAL(info) << "Resolved IP address: " << rpl.ip;
                }
            })
            .resolve_sync();
    }
    if (resolved_addr.empty()) {
        // no resolved addresses - try system resolving
        BOOST_LOG_TRIVIAL(error) << "PrusaSlicer failed to resolve hostname " << m_host << " into the IP address. Starting upload with system resolving.";
        return upload_inner_with_host(std::move(upload_data), prorgess_fn, error_fn, info_fn);
    } else if (resolved_addr.size() == 1) {
        // one address resolved - upload there
        return upload_inner_with_resolved_ip(std::move(upload_data), prorgess_fn, error_fn, info_fn, resolved_addr.front());
    }  else if (resolved_addr.size() == 2 && resolved_addr[0].is_v4() != resolved_addr[1].is_v4()) {
        // there are just 2 addresses and 1 is ip_v4 and other is ip_v6
        // try sending to both. (Then if both fail, show both error msg after second try)
        wxString error_message;
        if (!upload_inner_with_resolved_ip(std::move(upload_data), prorgess_fn
            , [&msg = error_message, resolved_addr](wxString error) { msg = GUI::format_wxstr("%1%: %2%", resolved_addr.front(), error); }
            , info_fn, resolved_addr.front())
            &&
            !upload_inner_with_resolved_ip(std::move(upload_data), prorgess_fn
            , [&msg = error_message, resolved_addr](wxString error) { msg += GUI::format_wxstr("\n%1%: %2%", resolved_addr.back(), error); }
            , info_fn, resolved_addr.back())
            ) {
 
            error_fn(error_message);
            return false;
        }
        return true;
    } else {
        // There are multiple addresses - user needs to choose which to use.
        size_t selected_index = resolved_addr.size(); 
        IPListDialog dialog(nullptr, boost::nowide::widen(m_host), resolved_addr, selected_index);
        if (dialog.ShowModal() == wxID_OK && selected_index < resolved_addr.size()) {    
            return upload_inner_with_resolved_ip(std::move(upload_data), prorgess_fn, error_fn, info_fn, resolved_addr[selected_index]);
        }
    }
    return false;
#endif // WIN32
}

References error, Slic3r::GUI::format_wxstr(), Slic3r::GUI::get_app_config(), Slic3r::OctoPrint::m_host, Slic3r::Bonjour::on_resolve(), Slic3r::Bonjour::set_hostname(), Slic3r::Bonjour::set_retries(), Slic3r::Bonjour::set_timeout(), Slic3r::OctoPrint::upload_inner_with_host(), and boost::nowide::widen().

Here is the call graph for this function:

upload_inner_with_host()

bool Slic3r::PrusaLink::upload_inner_with_host ( PrintHostUpload  upload_data, ProgressFn  prorgess_fn, ErrorFn  error_fn, InfoFn  info_fn  ) const

overrideprotectedvirtualinherited

Reimplemented from Slic3r::OctoPrint.

{
    const char* name = get_name();
 
    const auto upload_filename = upload_data.upload_path.filename();
    const auto upload_parent_path = upload_data.upload_path.parent_path();
 
    // If test fails, test_msg_or_host_ip contains the error message.
    // Otherwise on Windows it contains the resolved IP address of the host.
    wxString test_msg_or_host_ip;
    bool use_put = false;
    if (!test_with_method_check(test_msg_or_host_ip, use_put)) {
        error_fn(std::move(test_msg_or_host_ip));
        return false;
    }
 
    std::string url;
    std::string storage_path = (use_put ? "api/v1/files" : "api/files");
    storage_path += (upload_data.storage.empty() ? "/local" : upload_data.storage);
#ifdef WIN32
    // Workaround for Windows 10/11 mDNS resolve issue, where two mDNS resolves in succession fail.
    if (m_host.find("https://") == 0 || test_msg_or_host_ip.empty() || !GUI::get_app_config()->get_bool("allow_ip_resolve"))
#endif // _WIN32
    {
        // If https is entered we assume signed ceritificate is being used
        // IP resolving will not happen - it could resolve into address not being specified in cert
        url = make_url(storage_path);
    }
#ifdef WIN32
    else {
        // Workaround for Windows 10/11 mDNS resolve issue, where two mDNS resolves in succession fail.
        // Curl uses easy_getinfo to get ip address of last successful transaction.
        // If it got the address use it instead of the stored in "host" variable.
        // This new address returns in "test_msg_or_host_ip" variable.
        // Solves troubles of uploades failing with name address.
        // in original address (m_host) replace host for resolved ip 
        info_fn(L"resolve", test_msg_or_host_ip);
        url = substitute_host(make_url(storage_path), GUI::into_u8(test_msg_or_host_ip));
        BOOST_LOG_TRIVIAL(info) << "Upload address after ip resolve: " << url;
    }
#endif // _WIN32
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Uploading file %2% at %3%, filename: %4%, path: %5%, print: %6%, method: %7%")
        % name
        % upload_data.source_path
        % url
        % upload_filename.string()
        % upload_parent_path.string()
        % (upload_data.post_action == PrintHostPostUploadAction::StartPrint ? "true" : "false")
        % (use_put ? "PUT" : "POST");
 
    if (use_put)
        return put_inner(std::move(upload_data), std::move(url), name, prorgess_fn, error_fn, info_fn);
    return post_inner(std::move(upload_data), std::move(url), name, prorgess_fn, error_fn, info_fn);
}

References Slic3r::GUI::get_app_config(), Slic3r::AppConfig::get_bool(), Slic3r::PrusaLink::get_name(), Slic3r::GUI::into_u8(), L, Slic3r::OctoPrint::m_host, Slic3r::OctoPrint::make_url(), Slic3r::PrintHostUpload::post_action, Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), Slic3r::PrintHostUpload::source_path, Slic3r::StartPrint, Slic3r::PrintHostUpload::storage, Slic3r::PrusaLink::test_with_method_check(), and Slic3r::PrintHostUpload::upload_path.

Here is the call graph for this function:

validate_version_text()

bool Slic3r::SL1Host::validate_version_text ( const boost::optional< std::string > &  version_text ) const

overrideprotectedvirtual

Reimplemented from Slic3r::PrusaLink.

{
    return version_text ? boost::starts_with(*version_text, "Prusa SLA") : false;
}

Member Data Documentation

m_apikey

std::string Slic3r::OctoPrint::m_apikey

protectedinherited

Referenced by Slic3r::OctoPrint::get_apikey(), and Slic3r::OctoPrint::set_auth().

m_authorization_type

AuthorizationType Slic3r::PrusaLink::m_authorization_type

protectedinherited

Referenced by Slic3r::PrusaLink::set_auth().

m_cafile

std::string Slic3r::OctoPrint::m_cafile

protectedinherited

Referenced by Slic3r::OctoPrint::get_cafile(), and Slic3r::OctoPrint::set_auth().

m_host

std::string Slic3r::OctoPrint::m_host

protectedinherited

Referenced by Slic3r::OctoPrint::get_host(), Slic3r::PrusaLink::get_storage(), Slic3r::OctoPrint::make_url(), Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), Slic3r::OctoPrint::upload(), Slic3r::OctoPrint::upload_inner_with_host(), and Slic3r::PrusaLink::upload_inner_with_host().

m_password

std::string Slic3r::PrusaLink::m_password

protectedinherited

Referenced by Slic3r::PrusaLink::set_auth().

m_show_after_message

bool Slic3r::PrusaLink::m_show_after_message

privateinherited

Referenced by Slic3r::PrusaLink::post_inner(), and Slic3r::PrusaLink::put_inner().

m_ssl_revoke_best_effort

bool Slic3r::OctoPrint::m_ssl_revoke_best_effort

protectedinherited

Referenced by Slic3r::PrusaLink::get_storage(), Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), Slic3r::PrusaLink::test_with_method_check(), and Slic3r::OctoPrint::upload_inner_with_host().

m_username

std::string Slic3r::PrusaLink::m_username

protectedinherited

Referenced by Slic3r::PrusaLink::set_auth().

---

The documentation for this class was generated from the following files:

• src/slic3r/Utils/OctoPrint.hpp
• src/slic3r/Utils/OctoPrint.cpp