Slic3r::Moonraker Class Reference

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

Inheritance diagram for Slic3r::Moonraker:

Collaboration diagram for Slic3r::Moonraker:

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

Public Member Functions
	Moonraker (DynamicPrintConfig *config)
	~Moonraker () 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
bool	has_auto_discovery () const override
bool	can_test () const override
PrintHostPostUploadActions	get_post_upload_actions () 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

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

Protected Member Functions
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

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

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

Moonraker()

Slic3r::Moonraker::Moonraker

(

DynamicPrintConfig *

config

)

                                               :
    m_host(config->opt_string("print_host")),
    m_apikey(config->opt_string("printhost_apikey")),
    m_cafile(config->opt_string("printhost_cafile")),
    m_ssl_revoke_best_effort(config->opt_bool("printhost_ssl_ignore_revoke"))
{}

~Moonraker()

Slic3r::Moonraker::~Moonraker ( )

overridedefault

Member Function Documentation

can_test()

bool Slic3r::Moonraker::can_test ( ) const

inlineoverridevirtual

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(), 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(), 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::Moonraker::get_apikey ( ) const

inline

{ return m_apikey; }

References m_apikey.

get_cafile()

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

inline

{ return m_cafile; }

References m_cafile.

get_groups()

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

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

get_host()

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

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return m_host; }

References m_host.

get_name()

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

overridevirtual

Implements Slic3r::PrintHost.

{ return "Moonraker"; }

Referenced by test(), and upload().

Here is the caller graph for this function:

get_post_upload_actions()

PrintHostPostUploadActions Slic3r::Moonraker::get_post_upload_actions ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return PrintHostPostUploadAction::StartPrint; }

References 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 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()

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

inlinevirtualinherited

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

{ return false; }

get_test_failed_msg()

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

overridevirtual

Implements Slic3r::PrintHost.

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

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

Here is the call graph for this function:

get_test_ok_msg()

wxString Slic3r::Moonraker::get_test_ok_msg ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    return _(L("Connection to Moonraker works correctly."));
}

References _, and L.

has_auto_discovery()

bool Slic3r::Moonraker::has_auto_discovery ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return true; }

make_url()

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

protected

{
    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 test(), and upload().

Here is the caller graph for this function:

set_auth()

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

protectedvirtual

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

References Slic3r::Http::ca_file(), Slic3r::Http::header(), m_apikey, and m_cafile.

Referenced by test(), and upload().

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

overridevirtual

Implements Slic3r::PrintHost.

{
    // GET /server/info
 
    // 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("server/info");
 
    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([&](std::string body, unsigned) {
        BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got server/info: %2%") % name % body;
            
        try {
            // All successful HTTP requests will return a json encoded object in the form of :
            // {result: <response data>}
            std::stringstream ss(body);
            pt::ptree ptree;
            pt::read_json(ss, ptree);
            if (ptree.front().first != "result") {
                msg = "Could not parse server response";
                res = false;
                return;
            }
            if (!ptree.front().second.get_optional<std::string>("moonraker_version")) {
                msg = "Could not parse server response";
                res = false;
                return;
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Got version: %2%") % name % ptree.front().second.get_optional<std::string>("moonraker_version");
        } 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 error, Slic3r::PrintHost::format_error(), Slic3r::GUI::from_u8(), Slic3r::Http::get(), get_name(), m_ssl_revoke_best_effort, make_url(), and set_auth().

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

upload()

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

overridevirtual

Implements Slic3r::PrintHost.

{
    // POST /server/files/upload
 
    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.
    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("server/files/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", test_msg_or_host_ip);
        url = substitute_host(make_url("server/files/upload"), 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%")
        % name
        % upload_data.source_path
        % url
        % upload_filename.string()
        % upload_parent_path.string()
        % (upload_data.post_action == PrintHostPostUploadAction::StartPrint ? "true" : "false");
    /*
    The file must be uploaded in the request's body multipart/form-data (ie: <input type="file">). The following arguments may also be added to the form-data:
    root: The root location in which to upload the file.Currently this may be gcodes or config.If not specified the default is gcodes.
    path : This argument may contain a path(relative to the root) indicating a subdirectory to which the file is written.If a path is present the server will attempt to create any subdirectories that do not exist.
    checksum : A SHA256 hex digest calculated by the client for the uploaded file.If this argument is supplied the server will compare it to its own checksum calculation after the upload has completed.A checksum mismatch will result in a 422 error.
    Arguments available only for the gcodes root :
    print: If set to "true", Klippy will attempt to start the print after uploading.Note that this value should be a string type, not boolean.This provides compatibility with OctoPrint's upload API.
    */
    auto http = Http::post(std::move(url));
    set_auth(http);
    
    http.form_add("root", "gcodes");
    if (!upload_parent_path.empty())
        http.form_add("path", upload_parent_path.string());
    if (upload_data.post_action == PrintHostPostUploadAction::StartPrint)
        http.form_add("print", "true");
   
    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 error, Slic3r::PrintHost::format_error(), Slic3r::GUI::get_app_config(), Slic3r::AppConfig::get_bool(), get_name(), 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.

Here is the call graph for this function:

Member Data Documentation

m_apikey

std::string Slic3r::Moonraker::m_apikey

protected

Referenced by get_apikey(), and set_auth().

m_cafile

std::string Slic3r::Moonraker::m_cafile

protected

Referenced by get_cafile(), and set_auth().

m_host

std::string Slic3r::Moonraker::m_host

protected

Referenced by get_host(), make_url(), and upload().

m_ssl_revoke_best_effort

bool Slic3r::Moonraker::m_ssl_revoke_best_effort

protected

Referenced by test(), and upload().

---

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

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