Slic3r::ElegooLink Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/ElegooLink.hpp>

Inheritance diagram for Slic3r::ElegooLink:

Collaboration diagram for Slic3r::ElegooLink:

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

Public Member Functions
	ElegooLink (DynamicPrintConfig *config)
	~ElegooLink () override=default
const char *	get_name () const override
virtual bool	test (wxString &curl_msg) const override
wxString	get_test_ok_msg () const override
wxString	get_test_failed_msg (wxString &msg) const override
bool	upload (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const override
std::string	get_sn () const override
bool	has_auto_discovery () const override
bool	can_test () const override
PrintHostPostUploadActions	get_post_upload_actions () const override
bool	upload (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) 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
virtual bool	get_storage (wxArrayString &, wxArrayString &) const
virtual bool	is_cloud () const
virtual bool	is_logged_in () const
virtual void	log_out () const
virtual bool	get_login_url (wxString &auth_url) const

Static Public Member Functions
static std::string	get_print_host_webui (DynamicPrintConfig *config)
static PrintHost *	get_print_host (DynamicPrintConfig *config)
static int	get_err_code_from_body (const std::string &body)

Protected Member Functions
virtual bool	validate_version_text (const boost::optional< std::string > &version_text) const override
virtual bool	upload_inner_with_host (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const override
virtual bool	upload_inner_with_host (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const
virtual void	set_auth (Http &http) 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

Static Protected Member Functions
static wxString	timed_out_message ()

Protected Attributes
std::string	m_host
std::string	m_apikey
std::string	m_cafile
bool	m_ssl_revoke_best_effort

Private Member Functions
bool	elegoo_test (wxString &curl_msg) const
bool	elegoo_cc2_test (wxString &curl_msg) const
bool	print (WebSocketClient &client, std::string timeLapse, std::string heatedBedLeveling, std::string bedType, const std::string filename, ErrorFn error_fn) const
bool	checkResult (WebSocketClient &client, ErrorFn error_fn) const
bool	loopUpload (std::string url, PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const
bool	loopUploadCC2 (std::string url, const std::string &host_header, PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const
bool	uploadPart (Http &http, std::string md5, std::string uuid, std::string path, std::string filename, size_t filesize, size_t offset, size_t length, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const
bool	uploadPartCC2 (Http &http, const std::string &host_header, const std::string &token, const std::string &md5, const boost::filesystem::path &path, const std::string &filename, size_t filesize, size_t offset, size_t length, ProgressFn prorgess_fn, ErrorFn error_fn) const
std::string	cc2_token () const
std::string	make_cc2_info_url () const
std::string	make_cc2_upload_url () const

Private Attributes
std::string	m_printerModel

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

ElegooLink()

Slic3r::ElegooLink::ElegooLink

(

DynamicPrintConfig *

config

)

                                                    :
    OctoPrint(config), m_printerModel(config->opt_string("printer_model")) {
 
    }

References Slic3r::OctoPrint::OctoPrint(), and m_printerModel.

Here is the call graph for this function:

~ElegooLink()

Slic3r::ElegooLink::~ElegooLink ( )

overridedefault

Member Function Documentation

can_test()

bool Slic3r::ElegooLink::can_test ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return true; }

cc2_token()

std::string Slic3r::ElegooLink::cc2_token ( ) const

private

    {
        return get_cc2_token(m_apikey);
    }

References Slic3r::OctoPrint::m_apikey.

Referenced by elegoo_cc2_test(), loopUploadCC2(), and make_cc2_info_url().

Here is the caller graph for this function:

checkResult()

bool Slic3r::ElegooLink::checkResult ( WebSocketClient & client, ErrorFn error_fn ) const

private

                                                                                         {
                        res = false;
                        error_fn(_L("Start print timeout"));
                    }
            } catch (const std::exception& e) {
                std::cerr << "Error: " << e.what() << std::endl;
                BOOST_LOG_TRIVIAL(error) << "start print error: " << e.what();
                error_fn(_L("Start print failed") +"\n" +GUI::from_u8(e.what()));
                res=false;
            }
        return res;
    }
 
    bool ElegooLink::checkResult(WebSocketClient& client, ErrorFn error_fn) const
    {
        bool res = true;
        // create a random UUID generator
        boost::uuids::random_generator generator;
        // generate a UUID
        boost::uuids::uuid uuid        = generator();
        std::string        uuid_string = to_string(uuid);
        try {
            std::string requestID    = uuid_string;
            auto        now          = std::chrono::system_clock::now();
            auto        duration     = now.time_since_epoch();
            auto        milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
            std::string timestamp    = std::to_string(milliseconds);
            std::string jsonString   = R"({
                                        "Id":"",
                                        "Data":{
                                            "Cmd":)" +
                                     std::to_string(ElegooLinkCommand::ELEGOO_GET_STATUS) + R"(,
                                            "Data":{},
                                            "RequestID":")" +
                                     uuid_string + R"(",
                                            "MainboardID":"",
                                            "TimeStamp":)" +
                                     timestamp + R"(,
                                            "From":1
                                        }
                                    })";
            std::cout << "send: " << jsonString << std::endl;
            BOOST_LOG_TRIVIAL(info) << "start print, param: " << jsonString;
            bool needWrite = true;
            // wait 60s
            auto start_time = std::chrono::steady_clock::now();
            do {
                if (needWrite) {
                    client.send(jsonString);
                    needWrite = false;
                }
                std::string response = client.receive();
                std::cout << "Received: " << response << std::endl;
                BOOST_LOG_TRIVIAL(info) << "Received: " << response;
                pt::ptree          root;
                std::istringstream is(response);
                pt::read_json(is, root);
                auto status = root.get_child_optional("Status");
                if (status) {
                    auto currentStatus = status->get_child_optional("CurrentStatus");
                    if (currentStatus) {
                        std::vector<int> status;
                        for (auto& item : *currentStatus) {
                            status.push_back(item.second.get_value<int>());

Referenced by loopUpload().

Here is the caller graph for this function:

elegoo_cc2_test()

bool Slic3r::ElegooLink::elegoo_cc2_test ( wxString & curl_msg ) const

private

    {
        const char*  name  = get_name();
        bool         res   = true;
        const auto   token = cc2_token();
        auto         url   = make_cc2_info_url();
        auto         http  = Http::get(std::move(url));
 
        http.header("X-Token", token);
        http.header("Accept", "application/json");
        http.on_error([&](std::string body, std::string error, unsigned status) {
                BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error getting CC2 device info: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
                res = false;
                if (status == 401 || status == 403)
                    msg = format_error(body, _u8L("Invalid access code"), status);
                else
                    msg = format_error(body, error.empty() ? _u8L("CC2 device not detected") : error, status);
            })
            .on_complete([&](std::string body, unsigned status) {
                BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got CC2 device info: %2%") % name % body;
                std::string error_message;
                std::string serial_number;
                if (!parse_cc2_response(body, error_message, &serial_number)) {
                    res = false;
                    msg = format_error(body, error_message.empty() ? _u8L("CC2 device not detected") : error_message, status);
                    return;
                }
                persist_sn(Http::get_host_header_value(m_host), token, serial_number);
                res = true;
            })
#ifdef WIN32
            .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
            .on_ip_resolve([&](std::string address) {
                msg = GUI::from_u8(address);
            })
#endif // WIN32
            .perform_sync();
        return res;
    }

References _u8L, cc2_token(), Slic3r::PrintHost::format_error(), Slic3r::GUI::from_u8(), Slic3r::Http::get(), Slic3r::Http::get_host_header_value(), get_name(), Slic3r::http, Slic3r::OctoPrint::m_host, Slic3r::OctoPrint::m_ssl_revoke_best_effort, and make_cc2_info_url().

Referenced by test(), and upload_inner_with_host().

Here is the call graph for this function:

Here is the caller graph for this function:

elegoo_test()

bool Slic3r::ElegooLink::elegoo_test ( wxString & curl_msg ) const

private

                                                   {
 
    const char *name = get_name();
    bool res = true;
    auto url = make_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;
            // Check if the response contains "ELEGOO" in any case.
            // This is a simple check to see if the response is from an ElegooLink server.
            std::regex re("ELEGOO", std::regex::icase);
            std::smatch match;
            if (std::regex_search(body, match, re)) {
                res = true;
            } else {
                msg = format_error(body, _u8L("ElegooLink not detected"), 0);
                res = false;
            }
        })
#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 _u8L, Slic3r::PrintHost::format_error(), Slic3r::GUI::from_u8(), Slic3r::Http::get(), get_name(), Slic3r::http, Slic3r::OctoPrint::m_ssl_revoke_best_effort, Slic3r::OctoPrint::make_url(), and Slic3r::OctoPrint::set_auth().

Referenced by test(), and upload_inner_with_host().

Here is the call graph for this function:

Here is the caller graph for this function:

format_error()

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

protectedvirtualinherited

{
    if (status != 0) {
        const std::string reason = moonraker_error_reason(body);
        auto wxbody = wxString::FromUTF8(reason.empty() ? body : reason);
        return wxString::Format("HTTP %u: %s", status, wxbody);
    } else {
        if (error.find("curl:Timeout was reached") != std::string::npos) {
            return timed_out_message();
        }else if(error.find("curl:Couldn't resolve host name")!= std::string::npos){
            return _L("The Hostname/IP/URL could not be parsed, please check it and try again.");
        } else if (error.find("Connection was reset") != std::string::npos){
            return _L("File/data transfer interrupted. Please check the printer and network, then try it again.");
        }
        else {
            return wxString::FromUTF8(error.data());
        }
    }
}

References _L, and timed_out_message().

Referenced by Slic3r::Duet::connect(), Slic3r::UltiMaker::connect(), Slic3r::SimplyPrint::do_chunk_upload(), Slic3r::SimplyPrint::do_temp_upload(), Slic3r::ElegooLink::elegoo_cc2_test(), Slic3r::ElegooLink::elegoo_test(), Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), Slic3r::Flashforge::request_local_api_json(), Slic3r::Duet::start_print(), Slic3r::Moonraker::start_print(), Slic3r::UltiMaker::start_print(), Slic3r::AstroBox::test(), Slic3r::CrealityPrint::test(), Slic3r::ESP3D::test(), Slic3r::FlashAir::test(), Slic3r::Moonraker::test(), Slic3r::Obico::test(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), Slic3r::Repetier::test(), Slic3r::UltiMaker::test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::AstroBox::upload(), Slic3r::C3DPrinterOS::upload(), Slic3r::CrealityPrint::upload(), Slic3r::Duet::upload(), Slic3r::ESP3D::upload(), Slic3r::FlashAir::upload(), Slic3r::MKS::upload(), Slic3r::Moonraker::upload(), Slic3r::Obico::upload(), Slic3r::Repetier::upload(), Slic3r::UltiMaker::upload(), Slic3r::OctoPrint::upload_inner_with_host(), Slic3r::Flashforge::upload_local_api(), Slic3r::ElegooLink::uploadPart(), and Slic3r::ElegooLink::uploadPartCC2().

Here is the call graph for this function:

Here is the caller graph for this function:

get_apikey()

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

inlineinherited

{ return m_apikey; }

References 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 m_cafile.

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

Here is the caller graph for this function:

get_err_code_from_body()

int Slic3r::PrintHost::get_err_code_from_body ( const std::string & body )

staticinherited

{
    boost::property_tree::ptree root;
    std::istringstream iss(body);
    try {
        boost::property_tree::read_json(iss, root);
    } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << "PrintHost: response is not valid JSON: " << ex.what();
        return -1;
    }
 
    return root.get<int>("err", 0);
}

Referenced by Slic3r::Duet::connect(), Slic3r::UltiMaker::connect(), Slic3r::Duet::upload(), Slic3r::MKS::upload(), and Slic3r::UltiMaker::upload().

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 m_host.

get_login_url()

virtual bool Slic3r::PrintHost::get_login_url ( wxString & auth_url ) const

inlinevirtualinherited

Reimplemented in Slic3r::Obico.

{ return false; }

Referenced by Slic3r::GUI::PrinterCloudAuthDialog::PrinterCloudAuthDialog().

Here is the caller graph for this function:

get_name()

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

overridevirtual

Implements Slic3r::PrintHost.

{ return "ElegooLink"; }

Referenced by elegoo_cc2_test(), elegoo_test(), loopUpload(), loopUploadCC2(), uploadPart(), and uploadPartCC2().

Here is the caller graph for this function:

get_post_upload_actions()

PrintHostPostUploadActions Slic3r::ElegooLink::get_post_upload_actions ( ) const

overridevirtual

Implements Slic3r::PrintHost.

    {
        if (classify_printer_model(m_printerModel) == ElegooPrinterType::CC2) {
            return PrintHostPostUploadAction::None;
        } else {
            return PrintHostPostUploadAction::StartPrint;
        }
    }

References m_printerModel, Slic3r::None, and Slic3r::StartPrint.

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 htUltiMaker: return new UltiMaker(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 htESP3D:       return new ESP3D(config);
            case htCrealityPrint:    return new CrealityPrint(config);
            case htObico:     return new Obico(config);
            case htFlashforge: return new Flashforge(config);
            case htSimplyPrint: return new SimplyPrint(config);
            case htElegooLink: return new ElegooLink(config);
            case ht3DPrinterOS: return new C3DPrinterOS(config);
            case htMoonraker: return new Moonraker(config);
            default:          return nullptr;
        }
    } else {
        return new SL1Host(config);
    }
}

References Slic3r::ht3DPrinterOS, Slic3r::htAstroBox, Slic3r::htCrealityPrint, Slic3r::htDuet, Slic3r::htElegooLink, Slic3r::htESP3D, Slic3r::htFlashAir, Slic3r::htFlashforge, Slic3r::htMKS, Slic3r::htMoonraker, Slic3r::htObico, Slic3r::htOctoPrint, Slic3r::htPrusaConnect, Slic3r::htPrusaLink, Slic3r::htRepetier, Slic3r::htSimplyPrint, Slic3r::htUltiMaker, Slic3r::ConfigBase::option(), and Slic3r::ptFFF.

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::anonymous_namespace{PrinterWebViewHandler.cpp}::ElegooPrinterWebViewHandler::handle_get_sn_request(), Slic3r::GUI::anonymous_namespace{PrinterWebViewHandler.cpp}::ElegooPrinterWebViewHandler::handle_upload_request(), 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_print_host_webui()

std::string Slic3r::ElegooLink::get_print_host_webui ( DynamicPrintConfig * config )

static

    {
        if (config == nullptr)
            return {};
 
        std::string fallback_webui = config->opt_string("print_host_webui");
        if (fallback_webui.empty())
            fallback_webui = config->opt_string("print_host");
        if (!fallback_webui.empty()) {
            const bool has_http_scheme = boost::algorithm::istarts_with(fallback_webui, "http");
            const bool has_file_scheme = boost::algorithm::istarts_with(fallback_webui, "file:");
 
            if (!has_http_scheme && !has_file_scheme)
                fallback_webui = "http://" + fallback_webui;
        }
 
        const std::string host = config->opt_string("print_host");
        if (host.empty())
            return fallback_webui;
 
        if (classify_printer_model(config->opt_string("printer_model")) != ElegooPrinterType::CC2)
            return fallback_webui;
 
        std::string web_path = GUI::into_u8(GUI::file_url_from_path(boost::filesystem::path(resources_dir()) / "web/elegoolink/lan_service_web/index.html"));
        const std::string token   = get_cc2_token(config->opt_string("printhost_apikey"));
        const std::string host_ip = Http::get_host_header_value(host);
 
        // Pass sn= so the panel can subscribe to the correct MQTT topics.
        std::string sn = lookup_cc2_serial(config);
        if (sn.empty()) {
            std::string error_msg;
            auto http = Http::get("http://" + host_ip + "/system/info?X-Token=" + escape_string(token));
            http.timeout_connect(3).timeout_max(5);
            http.header("X-Token", token);
            http.header("Accept", "application/json");
            http.on_complete([&](std::string body, unsigned /*status*/) {
                parse_cc2_response(body, error_msg, &sn);
            }).perform_sync();
            if (!sn.empty())
                persist_sn(host_ip, token, sn);
        }
 
        web_path += "?access_code=" + token;
        web_path += "&ip=" + host_ip;
        if (!sn.empty())
            web_path += "&sn=" + sn;
        web_path += "&id=elegoo_123456";
 
        const std::string lang = GUI::wxGetApp().current_language_code_safe().utf8_string();
        if (!lang.empty())
            web_path += "&lang=" + lang;
 
        if (GUI::get_app_config()->get_bool("developer_mode"))
            web_path += "&dev=true";
 
        return web_path;
    }

References Slic3r::GUI::file_url_from_path(), Slic3r::Http::get(), Slic3r::GUI::get_app_config(), Slic3r::Http::get_host_header_value(), Slic3r::http, Slic3r::GUI::into_u8(), Slic3r::DynamicConfig::opt_string(), and Slic3r::resources_dir().

Referenced by Slic3r::PrintHost::get_print_host_webui().

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::Obico, and Slic3r::Repetier.

{ return false; }

get_sn()

std::string Slic3r::ElegooLink::get_sn ( ) const

overridevirtual

Get the serial number for connecting to the printer. For Elegoo CC2, the device details connection to the printer requires the serial number. Other print hosts do not need to implement this interface, and it returns an empty string by default.

Reimplemented from Slic3r::PrintHost.

    {
        // Panel IPC calls this on every load with a 10s timeout. Never block on HTTP
        // here — URL sn= and dev_sn must be enough; HTTP is only for get_print_host_webui.
        return lookup_cc2_serial_impl(m_printerModel, m_host, m_apikey);
    }

References Slic3r::OctoPrint::m_apikey, Slic3r::OctoPrint::m_host, and m_printerModel.

get_storage()

virtual bool Slic3r::PrintHost::get_storage ( wxArrayString & , wxArrayString &  ) const

inlinevirtualinherited

Reimplemented in Slic3r::Moonraker, Slic3r::PrusaConnect, and Slic3r::PrusaLink.

{ return false; }

get_test_failed_msg()

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

overridevirtual

Implements Slic3r::PrintHost.

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

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

Here is the call graph for this function:

get_test_ok_msg()

wxString Slic3r::ElegooLink::get_test_ok_msg ( ) const

overridevirtual

Implements Slic3r::PrintHost.

    {
        return _L("Connection to ElegooLink is working correctly.");
    }

References _L.

has_auto_discovery()

bool Slic3r::ElegooLink::has_auto_discovery ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return false; }

is_cloud()

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

inlinevirtualinherited

Reimplemented in Slic3r::C3DPrinterOS, Slic3r::Obico, and Slic3r::SimplyPrint.

{ return false; }

is_logged_in()

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

inlinevirtualinherited

Reimplemented in Slic3r::C3DPrinterOS, and Slic3r::SimplyPrint.

{ return false; }

log_out()

virtual void Slic3r::PrintHost::log_out ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::C3DPrinterOS, and Slic3r::SimplyPrint.

{}

loopUpload()

bool Slic3r::ElegooLink::loopUpload ( std::string url, PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn ) const

private

    {
        const char* name               = get_name();
        const auto  upload_filename = filename_to_utf8(upload_data.upload_path);
        std::string source_path     = path_to_utf8(upload_data.source_path);
 
        // calc file size
        boost::nowide::ifstream file(source_path, std::ios::binary | std::ios::ate);
        std::streamsize size = file.tellg();
        file.close();
        const std::string fileSize = std::to_string(size);
 
        // generate uuid
        boost::uuids::random_generator generator;
        boost::uuids::uuid             uuid        = generator();
        std::string                    uuid_string = to_string(uuid);
 
        std::string md5;
        bbl_calc_md5(source_path, md5);
 
        auto        http   = Http::post(url);
#ifdef WIN32
        // "Host" header is necessary here. In the workaround above (two mDNS..) we have got IP address from test connection 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). Also
        // when allow_ip_resolve = 0, this is not needed, but it should not break anything if it stays.
        // https://www.rfc-editor.org/rfc/rfc7230#section-5.4
        http.header("Host", Http::get_host_header_value(m_host));
        http.header("Accept", "application/json, text/plain, */*");
#endif // _WIN32
        set_auth(http);
 
        bool      res          = false;
        const int packageCount = (size + MAX_UPLOAD_PACKAGE_LENGTH - 1) / MAX_UPLOAD_PACKAGE_LENGTH;
 
        for (size_t i = 0; i < packageCount; i++) {
            BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Uploading file %2%/%3%") % name % (i + 1) % packageCount;
            const size_t offset = MAX_UPLOAD_PACKAGE_LENGTH * i;
            size_t       length = MAX_UPLOAD_PACKAGE_LENGTH;
            // if it is the last package, the length is the remainder of the file size divided by MAX_UPLOAD_PACKAGE_LENGTH
            if ((i == packageCount - 1) && (size % MAX_UPLOAD_PACKAGE_LENGTH > 0)) {
                length = size % MAX_UPLOAD_PACKAGE_LENGTH;
            }
            res = uploadPart(
                http, md5, uuid_string, source_path, upload_filename, size, offset, length,
                [size, i, progress_fn](Http::Progress progress, bool& cancel) {
                    Http::Progress p(0, 0, size, i * MAX_UPLOAD_PACKAGE_LENGTH + progress.ulnow, progress.buffer);
                    progress_fn(p, cancel);
                },
                error_fn, info_fn);
            if (!res) {
                break;
            }
        }
 
        if (res) {
            if (upload_data.post_action == PrintHostPostUploadAction::StartPrint) {
                // connect to websocket, since the upload is successful, the file will be printed
                std::string     wsUrl = Http::get_host_from_url(m_host);
                WebSocketClient client;
                try {
                    client.connect(wsUrl, "3030", "/websocket");
                } catch (std::exception& e) {
                    const auto errorString = std::string(e.what());
                    if (errorString.find("The WebSocket handshake was declined by the remote peer") != std::string::npos) {
                        // error_fn(
                        //     _L("The number of printer connections has exceeded the limit. Please disconnect other connections, restart the "
                        //        "printer and slicer, and then try again."));
                        error_fn(_L("The file has been transferred, but some unknown errors occurred. Please check the device page for the file and try to start printing again."));
                    } else {
                        error_fn(std::string("\n") + wxString::FromUTF8(e.what()));
                    }
                    return false;
                }
                std::string timeLapse = "0";
                std::string heatedBedLeveling = "0";
                std::string bedType           = "0";
                timeLapse         = upload_data.extended_info["timeLapse"];
                heatedBedLeveling = upload_data.extended_info["heatedBedLeveling"];
                bedType           = upload_data.extended_info["bedType"];
                
                std::this_thread::sleep_for(std::chrono::seconds(1));
                if (checkResult(client, error_fn)) {
                    // send print command
                    std::this_thread::sleep_for(std::chrono::seconds(1));
                    res = print(client, timeLapse, heatedBedLeveling, bedType, upload_filename, error_fn);
                }else{
                    res = false;
                }
            }
        }
        return res;
    }

References _L, Slic3r::bbl_calc_md5(), Slic3r::Http::Progress::buffer, checkResult(), Slic3r::PrintHostUpload::extended_info, Slic3r::Http::get_host_from_url(), Slic3r::Http::get_host_header_value(), get_name(), Slic3r::http, Slic3r::length(), Slic3r::OctoPrint::m_host, MAX_UPLOAD_PACKAGE_LENGTH, Slic3r::offset(), Slic3r::Http::post(), Slic3r::PrintHostUpload::post_action, print(), Slic3r::OctoPrint::set_auth(), Slic3r::PrintHostUpload::source_path, Slic3r::StartPrint, Slic3r::to_string(), Slic3r::Http::Progress::ulnow, Slic3r::PrintHostUpload::upload_path, and uploadPart().

Referenced by upload_inner_with_host().

Here is the call graph for this function:

Here is the caller graph for this function:

loopUploadCC2()

bool Slic3r::ElegooLink::loopUploadCC2 ( std::string url, const std::string & host_header, PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn ) const

private

    {
        BOOST_LOG_TRIVIAL(info) << get_name() << ": Uploading file to Elegoo CC2";
        const auto  upload_filename = filename_to_utf8(upload_data.upload_path);
        std::string source_path     = path_to_utf8(upload_data.source_path);
        std::string md5;
        bbl_calc_md5(source_path, md5);
        std::transform(md5.begin(), md5.end(), md5.begin(), [](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
 
        boost::nowide::ifstream file(source_path, std::ios::binary | std::ios::ate);
        if (!file.is_open()) {
            error_fn(_L("Failed to open file for upload."));
            return false;
        }
 
        const std::streamsize size = file.tellg();
        file.close();
        if (size <= 0) {
            error_fn(_L("The file is empty or could not be read."));
            return false;
        }
 
        if (md5.empty()) {
            error_fn(_L("Failed to calculate file checksum."));
            return false;
        }
 
        const std::string token        = cc2_token();
        const int         packageCount = static_cast<int>((size + MAX_UPLOAD_PACKAGE_LENGTH - 1) / MAX_UPLOAD_PACKAGE_LENGTH);
        auto              http         = Http::put2(url);
        http.timeout_connect(30)
            .timeout_max(180);
 
        bool              res          = false;
        for (int i = 0; i < packageCount; ++i) {
            const size_t offset = MAX_UPLOAD_PACKAGE_LENGTH * static_cast<size_t>(i);
            size_t       length = MAX_UPLOAD_PACKAGE_LENGTH;
            if (i == packageCount - 1 && size % MAX_UPLOAD_PACKAGE_LENGTH > 0)
                length = static_cast<size_t>(size % MAX_UPLOAD_PACKAGE_LENGTH);
 
            res = uploadPartCC2(
                http, host_header, token, md5, source_path, upload_filename, static_cast<size_t>(size), offset, length,
                [size, i, progress_fn](Http::Progress progress, bool& cancel) {
                    const size_t uploaded = static_cast<size_t>(i) * MAX_UPLOAD_PACKAGE_LENGTH + progress.ulnow;
                    Http::Progress merged(0, 0, static_cast<size_t>(size), std::min(static_cast<size_t>(size), uploaded), progress.buffer,
                                          progress.upload_spd);
                    progress_fn(merged, cancel);
                },
                error_fn);
            if (!res)
                break;
        }
 
        if (res && upload_data.post_action == PrintHostPostUploadAction::StartPrint)
            BOOST_LOG_TRIVIAL(info) << get_name() << ": CC2 upload completed; start print is not supported.";
 
        (void) info_fn;
        return res;
    }

References _L, Slic3r::bbl_calc_md5(), Slic3r::Http::Progress::buffer, cc2_token(), get_name(), Slic3r::http, Slic3r::length(), MAX_UPLOAD_PACKAGE_LENGTH, Slic3r::offset(), Slic3r::PrintHostUpload::post_action, Slic3r::Http::put2(), Slic3r::PrintHostUpload::source_path, Slic3r::StartPrint, Slic3r::Http::Progress::ulnow, Slic3r::PrintHostUpload::upload_path, Slic3r::Http::Progress::upload_spd, and uploadPartCC2().

Referenced by upload_inner_with_host().

Here is the call graph for this function:

Here is the caller graph for this function:

make_cc2_info_url()

std::string Slic3r::ElegooLink::make_cc2_info_url ( ) const

private

    {
        return make_url("system/info?X-Token=" + escape_string(cc2_token()));
    }

References cc2_token(), and Slic3r::OctoPrint::make_url().

Referenced by elegoo_cc2_test().

Here is the call graph for this function:

Here is the caller graph for this function:

make_cc2_upload_url()

std::string Slic3r::ElegooLink::make_cc2_upload_url ( ) const

private

    {
        return make_url("upload");
    }

References Slic3r::OctoPrint::make_url().

Referenced by upload_inner_with_host().

Here is the call graph for this function:

Here is the caller graph for this function:

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 m_host.

Referenced by Slic3r::ElegooLink::elegoo_test(), Slic3r::PrusaLink::get_storage(), Slic3r::ElegooLink::make_cc2_info_url(), Slic3r::ElegooLink::make_cc2_upload_url(), test(), Slic3r::PrusaLink::test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::ElegooLink::upload_inner_with_host(), upload_inner_with_host(), and Slic3r::PrusaLink::upload_inner_with_host().

Here is the caller graph for this function:

print()

bool Slic3r::ElegooLink::print ( WebSocketClient & client, std::string timeLapse, std::string heatedBedLeveling, std::string bedType, const std::string filename, ErrorFn error_fn ) const

private

    {
 
        // convert bedType to 0 or 1, 0 is PTE, 1 is PC
        if (bedType == std::to_string((int)BedType::btPC)){
            bedType = "1";
        }else{
            bedType = "0";
        }
        bool res = false;
        // create a random UUID generator
        boost::uuids::random_generator generator;
        // generate a UUID
        boost::uuids::uuid uuid = generator();
        std::string uuid_string = to_string(uuid);
        try {
            std::string requestID = uuid_string; 
            auto now = std::chrono::system_clock::now();
            auto duration = now.time_since_epoch();
            auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
            std::string timestamp = std::to_string(milliseconds);     
            std::string jsonString = R"({
                                        "Id":"",
                                        "Data":{
                                            "Cmd":)"+std::to_string(ElegooLinkCommand::ELEGOO_START_PRINT)+R"(,
                                            "Data":{
                                                "Filename":"/local/)" + filename + R"(",
                                                "StartLayer":0,
                                                "Calibration_switch":)" + heatedBedLeveling + R"(,
                                                "PrintPlatformType":)" + bedType + R"(,
                                                "Tlp_Switch":)" + timeLapse + R"(
                                            },
                                            "RequestID":")"+ uuid_string + R"(",
                                            "MainboardID":"",
                                            "TimeStamp":)" + timestamp + R"(,
                                            "From":1
                                        }
                                    })";
                    std::cout << "send: " << jsonString << std::endl;
                    BOOST_LOG_TRIVIAL(info) << "start print, param: " << jsonString;
                    client.send(jsonString);
                    // wait 30s
                    auto start_time = std::chrono::steady_clock::now();
                    do{
                        std::string response = client.receive();
                        std::cout << "Received: " << response << std::endl;
                        BOOST_LOG_TRIVIAL(info) << "Received: " << response;
 
                        //sample response
                        // {"Id":"979d4C788A4a78bC777A870F1A02867A","Data":{"Cmd":128,"Data":{"Ack":1},"RequestID":"5223de52cc7642ae8d7924f9dd46f6ad","MainboardID":"1c7319d30105041800009c0000000000","TimeStamp":1735032553},"Topic":"sdcp/response/1c7319d30105041800009c0000000000"}  
                        pt::ptree root;
                        std::istringstream is(response);
                        pt::read_json(is, root);
 
                        auto data = root.get_child_optional("Data");
                        if(!data){
                            BOOST_LOG_TRIVIAL(info) << "wait for start print response";
                            continue;
                        }
                        auto cmd = data->get_optional<int>("Cmd");
                        if(!cmd){
                            BOOST_LOG_TRIVIAL(info) << "wait for start print response";
                            continue;
                        }
                        if(*cmd == ElegooLinkCommand::ELEGOO_START_PRINT){
                            auto _ack = data->get_optional<int>("Data.Ack");
                            if(!_ack){
                                BOOST_LOG_TRIVIAL(error) << "start print failed, ack not found";
                                error_fn(_L("Error code not found"));
                                break;
                            }
                            auto ack = static_cast<ElegooLinkStartPrintAck>(*_ack);
                            if(ack == ElegooLinkStartPrintAck::SDCP_PRINT_CTRL_ACK_OK){
                                res = true;
                            }else{
                                res = false;
                                BOOST_LOG_TRIVIAL(error) << "start print failed: ack: " << ack;
                                wxString error_message = "";
                                switch(ack){
                                    case ElegooLinkStartPrintAck::SDCP_PRINT_CTRL_ACK_BUSY:
                                    {   
                                        error_message =_L("The printer is busy, please check the device page for the file and try to start printing again.");
                                        break;
                                    }
                                    case ElegooLinkStartPrintAck::SDCP_PRINT_CTRL_ACK_NOT_FOUND:
                                    {
                                        error_message =_(L("The file is lost, please check and try again."));
                                        break;
                                    }
                                    case ElegooLinkStartPrintAck::SDCP_PRINT_CTRL_ACK_MD5_FAILED:
                                    {
                                        error_message =_(L("The file is corrupted, please check and try again."));
                                        break;
                                    }
                                    case ElegooLinkStartPrintAck::SDCP_PRINT_CTRL_ACK_FILEIO_FAILED:
                                    case ElegooLinkStartPrintAck::SDCP_PRINT_CTRL_ACK_INVALID_RESOLUTION:
                                    case ElegooLinkStartPrintAck::SDCP_PRINT_CTRL_ACK_UNKNOW_FORMAT:
                                    {
                                        error_message =_(L("Transmission abnormality, please check and try again."));
                                        break;
                                    }
                                    case ElegooLinkStartPrintAck::SDCP_PRINT_CTRL_ACK_UNKNOW_MODEL:
                                    {
                                        error_message =_(L("The file does not match the printer, please check and try again."));
                                        break;
                                    }
                                    default:
                                    {
                                        error_message =_L("Unknown error");
                                        break;
                                    }
                                }
 
                                error_message += " " + wxString::Format(_L("Error code: %d"),ack);
                                error_fn(error_message);

References _, _L, Slic3r::btPC, Slic3r::ELEGOO_START_PRINT, L, Slic3r::SDCP_PRINT_CTRL_ACK_BUSY, Slic3r::SDCP_PRINT_CTRL_ACK_FILEIO_FAILED, Slic3r::SDCP_PRINT_CTRL_ACK_INVALID_RESOLUTION, Slic3r::SDCP_PRINT_CTRL_ACK_MD5_FAILED, Slic3r::SDCP_PRINT_CTRL_ACK_NOT_FOUND, Slic3r::SDCP_PRINT_CTRL_ACK_OK, Slic3r::SDCP_PRINT_CTRL_ACK_UNKNOW_FORMAT, Slic3r::SDCP_PRINT_CTRL_ACK_UNKNOW_MODEL, and Slic3r::to_string().

Referenced by loopUpload().

Here is the call graph for this function:

Here is the caller graph for this function:

set_auth()

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

protectedvirtualinherited

Reimplemented in Slic3r::PrusaLink.

{
    http.header("X-Api-Key", m_apikey);
 
    if (!m_cafile.empty()) {
        http.ca_file(m_cafile);
    }
}

References Slic3r::http, m_apikey, and m_cafile.

Referenced by Slic3r::ElegooLink::elegoo_test(), Slic3r::ElegooLink::loopUpload(), test(), and upload_inner_with_host().

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::ElegooLink::test ( wxString & curl_msg ) const

overridevirtual

Reimplemented from Slic3r::OctoPrint.

                                                 {
        switch (classify_printer_model(m_printerModel)) {
        case ElegooPrinterType::Other:
            return OctoPrint::test(curl_msg);
        case ElegooPrinterType::CC2:
            return elegoo_cc2_test(curl_msg);
        case ElegooPrinterType::CC:
            return elegoo_test(curl_msg);
        }
        return false;
    }

References elegoo_cc2_test(), elegoo_test(), m_printerModel, and Slic3r::OctoPrint::test().

Here is the call graph for this function:

timed_out_message()

wxString Slic3r::PrintHost::timed_out_message ( )

staticprotectedinherited

{
    return _L("Connection timed out. Please check if the printer and computer network are functioning properly, and confirm that they are on the same network.");
}

References _L.

Referenced by format_error(), and Slic3r::CrealityPrint::start_print().

Here is the caller graph for this function:

upload() [1/2]

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

override

    {
    #ifndef WIN32
        return upload_inner_with_host(std::move(upload_data), prorgess_fn, error_fn, info_fn);
    #else
        std::string host = Http::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) << "ElegooLink 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 Slic3r::GUI::format_wxstr(), Slic3r::GUI::get_app_config(), Slic3r::Http::get_host_from_url(), Slic3r::OctoPrint::m_host, Slic3r::Bonjour::on_resolve(), Slic3r::Bonjour::set_hostname(), Slic3r::Bonjour::set_retries(), Slic3r::Bonjour::set_timeout(), and upload_inner_with_host().

Here is the call graph for this function:

upload() [2/2]

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 = Http::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 Slic3r::GUI::format_wxstr(), Slic3r::GUI::get_app_config(), Slic3r::Http::get_host_from_url(), m_host, Slic3r::Bonjour::on_resolve(), Slic3r::Bonjour::set_hostname(), Slic3r::Bonjour::set_retries(), Slic3r::Bonjour::set_timeout(), and upload_inner_with_host().

Here is the call graph for this function:

upload_inner_with_host() [1/2]

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

overrideprotectedvirtual

    {
        const auto printer_type = classify_printer_model(m_printerModel);
 
        if (printer_type == ElegooPrinterType::Other)
            return OctoPrint::upload_inner_with_host(std::move(upload_data), prorgess_fn, error_fn, info_fn);
 
        if (printer_type == ElegooPrinterType::CC2) {
            wxString cc2_msg;
            if (!elegoo_cc2_test(cc2_msg)) {
                error_fn(std::move(cc2_msg));
                return false;
            }
 
            std::string url;
#ifdef WIN32
            if (m_host.find("https://") == 0 || cc2_msg.empty() || !GUI::get_app_config()->get_bool("allow_ip_resolve"))
#endif // _WIN32
            {
                url = make_cc2_upload_url();
            }
#ifdef WIN32
            else {
                info_fn(L"resolve", cc2_msg);
                url = substitute_host(make_cc2_upload_url(), GUI::into_u8(cc2_msg));
                BOOST_LOG_TRIVIAL(info) << "CC2 upload address after ip resolve: " << url;
            }
#endif // _WIN32
 
            return loopUploadCC2(url, Http::get_host_header_value(m_host), std::move(upload_data), prorgess_fn, error_fn, info_fn);
        }
 
        wxString legacy_msg;
        if(!elegoo_test(legacy_msg)){
            error_fn(std::move(legacy_msg));
            return false;
        }
 
        std::string url;
    #ifdef WIN32
        // Workaround for Windows 10/11 mDNS resolve issue, where two mDNS resolves in succession fail.
        if (m_host.find("https://") == 0 || legacy_msg.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("uploadFile/upload");
        }
    #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", legacy_msg);
            url = substitute_host(make_url("uploadFile/upload"), GUI::into_u8(legacy_msg));
            BOOST_LOG_TRIVIAL(info) << "Upload address after ip resolve: " << url;
        }
    #endif // _WIN32
 
        bool res = loopUpload(url, upload_data, prorgess_fn, error_fn, info_fn);
        return res;
    }

References elegoo_cc2_test(), elegoo_test(), Slic3r::GUI::get_app_config(), Slic3r::Http::get_host_header_value(), Slic3r::GUI::into_u8(), L, loopUpload(), loopUploadCC2(), Slic3r::OctoPrint::m_host, m_printerModel, make_cc2_upload_url(), Slic3r::OctoPrint::make_url(), and Slic3r::OctoPrint::upload_inner_with_host().

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

upload_inner_with_host() [2/2]

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

protectedvirtualinherited

{
    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;
    if (!test(test_msg_or_host_ip)) {
        error_fn(std::move(test_msg_or_host_ip));
        return false;
    }
 
    std::string url;
    bool res = true;
 
#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("api/files/local");
    }
#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("api/files/local"), GUI::into_u8(test_msg_or_host_ip));
        BOOST_LOG_TRIVIAL(info) << "Upload address after ip resolve: " << url;
    }
#endif // _WIN32
 
    const std::string plateindex = upload_data.extended("plateindex");
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Uploading file %2% at %3%, filename: %4%, path: %5%, print: %6%, plateindex: %7%")
        % name
        % upload_data.source_path
        % url
        % upload_filename.string()
        % upload_parent_path.string()
        % (upload_data.post_action == PrintHostPostUploadAction::StartPrint ? "true" : "false")
        % (plateindex.empty() ? "-" : plateindex);
 
    auto http = Http::post(std::move(url));
#ifdef WIN32
    // "Host" header is necessary here. In the workaround above (two mDNS..) we have got IP address from test connection 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).
    // Also when allow_ip_resolve = 0, this is not needed, but it should not break anything if it stays.
    // https://www.rfc-editor.org/rfc/rfc7230#section-5.4
    http.header("Host", Http::get_host_header_value(m_host));
#endif // _WIN32
    set_auth(http);
    http.form_add("print", upload_data.post_action == PrintHostPostUploadAction::StartPrint ? "true" : "false")
        .form_add("path", upload_parent_path.string());     // XXX: slashes on windows ???
    //ORCA: gcode inside a .gcode.3mf is index-coded (Metadata/plate_<N>.gcode), so the upload names the
    //      plate via a 1-based `plateindex` (see Plater::send_gcode_legacy); servers that don't use it
    //      ignore the unknown form field.
    if (!plateindex.empty())
        http.form_add("plateindex", plateindex);
    http.form_add_file("file", upload_data.source_path.string(), upload_filename.string())
        .on_complete([&](std::string body, unsigned status) {
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: File uploaded: HTTP %2%: %3%") % name % status % body;
        })
        .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) << name << ": Upload canceled";
                res = false;
            }
        })
#ifdef WIN32
        .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
#endif
        .perform_sync();
 
    return res;
}

References Slic3r::PrintHostUpload::extended(), Slic3r::PrintHost::format_error(), Slic3r::GUI::get_app_config(), Slic3r::Http::get_host_header_value(), get_name(), Slic3r::http, Slic3r::GUI::into_u8(), L, m_host, m_ssl_revoke_best_effort, make_url(), Slic3r::Http::post(), Slic3r::PrintHostUpload::post_action, set_auth(), Slic3r::PrintHostUpload::source_path, Slic3r::StartPrint, test(), and Slic3r::PrintHostUpload::upload_path.

Referenced by upload(), and Slic3r::ElegooLink::upload_inner_with_host().

Here is the call graph for this function:

Here is the caller graph for this function:

uploadPart()

bool Slic3r::ElegooLink::uploadPart ( Http & http, std::string md5, std::string uuid, std::string path, std::string filename, size_t filesize, size_t offset, size_t length, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn ) const

private

    {
        const char* name   = get_name();
        bool        result = false;
        http.form_clear();
        http.form_add("Check", "1")
            .form_add("S-File-MD5", md5)
            .form_add("Offset", std::to_string(offset))
            .form_add("Uuid", uuid)
            .form_add("TotalSize", std::to_string(filesize))
            .form_add_file("File", path, filename, offset, length)
            .on_complete([&](std::string body, unsigned status) {
                BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: File uploaded: HTTP %2%: %3%") % name % status % body;
                if (status == 200) {
                    try {
                        pt::ptree          root;
                        std::istringstream is(body);
                        pt::read_json(is, root);
                        std::string code = root.get<std::string>("code");
                        if (code == "000000") {
                            // info_fn(L"complete", wxString());
                            result = true;
                        } else {
                            // get error messages
                            pt::ptree   messages      = root.get_child("messages");
                            std::string error_message = (boost::format(_u8L("Error code: %1%")) % code).str() + "\n";
                            for (pt::ptree::value_type& message : messages) {
                                std::string field = message.second.get<std::string>("field");
                                std::string msg   = message.second.get<std::string>("message");
                                error_message += field + ":" + msg + "\n";
                            }
                            error_fn(wxString::FromUTF8(error_message));
                        }
                    } catch (...) {
                        BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error parsing response: %2%") % name % body;
                        error_fn(_L("Error parsing response"));
                    }
                } else {
                    error_fn(format_error(body, _u8L("Upload failed"), status));
                }
            })
            .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));
            })
            .on_progress([&](Http::Progress progress, bool& cancel) {
                // If upload is finished, do not call progress_fn
                // on_complete will be called after some time, so we do not need to call it here
                // Because some devices will call on_complete after the upload progress reaches 100%,
                // so we need to process it here, based on on_complete
                if (progress.ultotal == progress.ulnow) {
                    // Upload is finished
                    return;
                }
                prorgess_fn(std::move(progress), cancel);
                if (cancel) {
                    // Upload was canceled
                    BOOST_LOG_TRIVIAL(info) << name << ": Upload canceled";
                }
            })
#ifdef WIN32
            .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
#endif
            .perform_sync();
        return result;
    }

References _L, _u8L, Slic3r::PrintHost::format_error(), get_name(), Slic3r::http, Slic3r::length(), Slic3r::OctoPrint::m_ssl_revoke_best_effort, Slic3r::offset(), Slic3r::Http::Progress::ulnow, and Slic3r::Http::Progress::ultotal.

Referenced by loopUpload().

Here is the call graph for this function:

Here is the caller graph for this function:

uploadPartCC2()

bool Slic3r::ElegooLink::uploadPartCC2 ( Http & http, const std::string & host_header, const std::string & token, const std::string & md5, const boost::filesystem::path & path, const std::string & filename, size_t filesize, size_t offset, size_t length, ProgressFn prorgess_fn, ErrorFn error_fn ) const

private

    {
        const char* name = get_name();
 
        boost::nowide::ifstream file(path, std::ios::binary);
        if (!file.is_open()) {
            error_fn(_L("Failed to open file for upload."));
            return false;
        }
 
        file.seekg(static_cast<std::streamoff>(offset), std::ios::beg);
        std::string chunk(length, '\0');
        file.read(chunk.data(), static_cast<std::streamsize>(length));
        if (!file && static_cast<size_t>(file.gcount()) != length) {
            error_fn(_L("Failed to read file chunk for upload."));
            return false;
        }
        chunk.resize(static_cast<size_t>(file.gcount()));
 
        const size_t end_offset = offset + chunk.size() - 1;
        const auto   range      = std::string("bytes ") + std::to_string(offset) + "-" + std::to_string(end_offset) + "/" + std::to_string(filesize);
 
        bool result = false;
        http.headers_reset();
        if (!host_header.empty())
            http.header("Host", host_header);
        http.header("Accept", "application/json")
            .header("Content-Type", "application/octet-stream")
            .header("Content-Length", std::to_string(chunk.size()))
            .header("Content-Range", range)
            .header("X-File-Name", filename)
            .header("X-File-MD5", md5)
            .header("X-Token", token)
            .set_post_body(chunk)
            .on_complete([&](std::string body, unsigned status) {
                BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: CC2 chunk uploaded: HTTP %2%: %3%") % name % status % body;
                std::string error_message;
                if (!parse_cc2_response(body, error_message)) {
                    error_fn(format_error(body, error_message.empty() ? _u8L("CC2 upload failed") : error_message, status));
                    return;
                }
                result = true;
            })
            .on_error([&](std::string body, std::string error, unsigned status) {
                BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error uploading CC2 chunk: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
                if (status == 401 || status == 403)
                    error_fn(format_error(body, _u8L("Invalid access code"), status));
                else
                    error_fn(format_error(body, error.empty() ? _u8L("CC2 upload failed") : error, status));
            })
            .on_progress([&](Http::Progress progress, bool& cancel) {
                if (progress.ultotal == progress.ulnow)
                    return;
                prorgess_fn(std::move(progress), cancel);
                if (cancel)
                    BOOST_LOG_TRIVIAL(info) << name << ": CC2 upload canceled";
            })
#ifdef WIN32
            .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
#endif
            .perform_sync();
 
        return result;
    }

References _L, _u8L, Slic3r::PrintHost::format_error(), get_name(), Slic3r::http, Slic3r::length(), Slic3r::OctoPrint::m_ssl_revoke_best_effort, Slic3r::offset(), Slic3r::range(), Slic3r::Http::Progress::ulnow, and Slic3r::Http::Progress::ultotal.

Referenced by loopUploadCC2().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_version_text()

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

overrideprotectedvirtual

Reimplemented from Slic3r::OctoPrint.

    {
        return  true;
    }

Member Data Documentation

m_apikey

std::string Slic3r::OctoPrint::m_apikey

protectedinherited

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

m_cafile

std::string Slic3r::OctoPrint::m_cafile

protectedinherited

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

m_host

std::string Slic3r::OctoPrint::m_host

protectedinherited

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

m_printerModel

std::string Slic3r::ElegooLink::m_printerModel

private

Referenced by ElegooLink(), get_post_upload_actions(), get_sn(), test(), and upload_inner_with_host().

m_ssl_revoke_best_effort

bool Slic3r::OctoPrint::m_ssl_revoke_best_effort

protectedinherited

Referenced by OctoPrint(), Slic3r::ElegooLink::elegoo_cc2_test(), Slic3r::ElegooLink::elegoo_test(), Slic3r::PrusaLink::get_storage(), Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), test(), Slic3r::PrusaLink::test(), Slic3r::PrusaLink::test_with_method_check(), upload_inner_with_host(), Slic3r::ElegooLink::uploadPart(), and Slic3r::ElegooLink::uploadPartCC2().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/ElegooLink.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/ElegooLink.cpp