Slic3r::Repetier Class Reference

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

Inheritance diagram for Slic3r::Repetier:

Collaboration diagram for Slic3r::Repetier:

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

Public Member Functions
	Repetier (DynamicPrintConfig *config)
	~Repetier () override=default
const char *	get_name () const override
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
bool	supports_multiple_printers () const override
std::string	get_host () const override
bool	get_groups (wxArrayString &groups) const override
bool	get_printers (wxArrayString &printers) const override
virtual bool	get_storage (wxArrayString &, wxArrayString &) const

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

Protected Member Functions
virtual wxString	format_error (const std::string &body, const std::string &error, unsigned status) const

Private Member Functions
void	set_auth (Http &http) const
std::string	make_url (const std::string &path) const

Private Attributes
std::string	host
std::string	apikey
std::string	cafile
std::string	port

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

Repetier()

Slic3r::Repetier::Repetier

(

DynamicPrintConfig *

config

)

                                             :
    host(config->opt_string("print_host")),
    apikey(config->opt_string("printhost_apikey")),
    cafile(config->opt_string("printhost_cafile")),
    port(config->opt_string("printhost_port"))
{}

~Repetier()

Slic3r::Repetier::~Repetier ( )

overridedefault

Member Function Documentation

can_test()

bool Slic3r::Repetier::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(), Slic3r::Moonraker::test(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::AstroBox::upload(), Slic3r::Duet::upload(), Slic3r::FlashAir::upload(), Slic3r::MKS::upload(), Slic3r::Moonraker::upload(), upload(), and Slic3r::OctoPrint::upload_inner_with_host().

Here is the caller graph for this function:

get_groups()

bool Slic3r::Repetier::get_groups ( wxArrayString &  groups ) const

overridevirtual

Reimplemented from Slic3r::PrintHost.

{
    bool res = true;
    
    const char *name = get_name();
    auto url = make_url((boost::format("printer/api/%1%") % port).str());
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Get groups at: %2%") % name % url;
 
    auto http = Http::get(std::move(url));
    set_auth(http);
    http.form_add("a", "listModelGroups");
    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;
        })
        .on_complete([&](std::string body, unsigned) {
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got groups: %2%") % name % body;
 
            try {
                std::stringstream ss(body);
                pt::ptree ptree;
                pt::read_json(ss, ptree);
 
                BOOST_FOREACH(boost::property_tree::ptree::value_type &v, ptree.get_child("groupNames.")) {
                    if (v.second.data() == "#") {
                        groups.push_back(_L("Default"));
                    } else {
                        // Is it safe to assume that the data are utf-8 encoded?
                        groups.push_back(GUI::from_u8(v.second.data()));
                    }
                }
            }
            catch (const std::exception &) {
                //msg = "Could not parse server response";
                res = false;
            }
        })
        .perform_sync();
 
    return res;
}

References _L, error, Slic3r::GUI::from_u8(), Slic3r::Http::get(), get_name(), make_url(), port, and set_auth().

Here is the call graph for this function:

get_host()

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

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return host; }

References host.

get_name()

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

overridevirtual

Implements Slic3r::PrintHost.

{ return "Repetier"; }

Referenced by get_groups(), get_printers(), test(), and upload().

Here is the caller graph for this function:

get_post_upload_actions()

PrintHostPostUploadActions Slic3r::Repetier::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()

bool Slic3r::Repetier::get_printers ( wxArrayString &  printers ) const

overridevirtual

Reimplemented from Slic3r::PrintHost.

{
    const char *name = get_name();
 
    bool res = true;
    auto url = make_url("printer/list");
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: List printers 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 listing printers: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
            res = false;
        })
        .on_complete([&](std::string body, unsigned http_status) {
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got printers: %2%, HTTP status: %3%") % name % body % http_status;
            
            if (http_status != 200)
                throw HostNetworkError(GUI::format(_L("HTTP status: %1%\nMessage body: \"%2%\""), http_status, body));
 
            std::stringstream ss(body);
            pt::ptree ptree;
            try {
                pt::read_json(ss, ptree);
            } catch (const pt::ptree_error &err) {
                throw HostNetworkError(GUI::format(_L("Parsing of host response failed.\nMessage body: \"%1%\"\nError: \"%2%\""), body, err.what()));
            }
            
            const auto error = ptree.get_optional<std::string>("error");
            if (error)
                throw HostNetworkError(*error);
 
            try {
                BOOST_FOREACH(boost::property_tree::ptree::value_type &v, ptree.get_child("data.")) {
                    const auto port = v.second.get<std::string>("slug");
                    printers.push_back(Slic3r::GUI::from_u8(port));
                }
            } catch (const std::exception &err) {
                throw HostNetworkError(GUI::format(_L("Enumeration of host printers failed.\nMessage body: \"%1%\"\nError: \"%2%\""), body, err.what()));
            }
        })
        .perform_sync();
 
    return res;
}

References _L, error, Slic3r::GUI::format(), Slic3r::GUI::from_u8(), Slic3r::Http::get(), get_name(), make_url(), port, and set_auth().

Here is the call graph for this function:

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::Repetier::get_test_failed_msg ( wxString &  msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{
        return GUI::format_wxstr("%s: %s\n\n%s"
        , _L("Could not connect to Repetier")
        , msg
        , _L("Note: Repetier version at least 0.90.0 is required."));
}

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

Here is the call graph for this function:

get_test_ok_msg()

wxString Slic3r::Repetier::get_test_ok_msg ( ) const

overridevirtual

Implements Slic3r::PrintHost.

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

References _, and L.

has_auto_discovery()

bool Slic3r::Repetier::has_auto_discovery ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return false; }

make_url()

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

private

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

References host.

Referenced by get_groups(), get_printers(), test(), and upload().

Here is the caller graph for this function:

set_auth()

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

private

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

References apikey, Slic3r::Http::ca_file(), cafile, and Slic3r::Http::header().

Referenced by get_groups(), get_printers(), test(), and upload().

Here is the call graph for this function:

Here is the caller graph for this function:

supports_multiple_printers()

bool Slic3r::Repetier::supports_multiple_printers ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::PrintHost.

{ return true; }

test()

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

overridevirtual

Implements Slic3r::PrintHost.

{
    // 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("printer/info");
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: List 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 version: %2%") % name % body;
 
            try {
                std::stringstream ss(body);
                pt::ptree ptree;
                pt::read_json(ss, ptree);
 
                const auto text = ptree.get_optional<std::string>("name");
                const auto soft = ptree.get_optional<std::string>("software");
                res = validate_repetier(text, soft);
                if (! res) {
                    msg = GUI::format_wxstr(_L("Mismatched type of print host: %s"), (soft ? *soft : (text ? *text : "Repetier")));
                }
            }
            catch (const std::exception &) {
                res = false;
                msg = "Could not parse server response";
            }
        })
        .perform_sync();
 
    return res;
}

References _L, error, Slic3r::PrintHost::format_error(), Slic3r::GUI::format_wxstr(), Slic3r::Http::get(), get_name(), make_url(), set_auth(), and Slic3r::validate_repetier().

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

upload()

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

overridevirtual

Implements Slic3r::PrintHost.

{
    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();
 
    wxString test_msg;
    if (! test(test_msg)) {
        error_fn(std::move(test_msg));
        return false;
    }
 
    bool res = true;
 
    auto url = upload_data.post_action == PrintHostPostUploadAction::StartPrint
        ? make_url((boost::format("printer/job/%1%") % port).str())
        : make_url((boost::format("printer/model/%1%") % port).str());
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Uploading file %2% at %3%, filename: %4%, path: %5%, print: %6%, group: %7%")
        % name
        % upload_data.source_path
        % url
        % upload_filename.string()
        % upload_parent_path.string()
        % (upload_data.post_action == PrintHostPostUploadAction::StartPrint ? "true" : "false")
        % upload_data.group;
 
    auto http = Http::post(std::move(url));
    set_auth(http);
 
    if (! upload_data.group.empty() && upload_data.group != _u8L("Default")) {
        http.form_add("group", upload_data.group);
    }
 
    if(upload_data.post_action == PrintHostPostUploadAction::StartPrint) {
        http.form_add("name", upload_filename.string());
        http.form_add("autostart", "true"); // See https://github.com/prusa3d/PrusaSlicer/issues/7807#issuecomment-1235519371
    }
 
    http.form_add("a", "upload")
        .form_add_file("filename", 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) << "Repetier: Upload canceled";
                res = false;
            }
        })
        .perform_sync();
 
    return res;
}

References _u8L, error, Slic3r::PrintHost::format_error(), get_name(), Slic3r::PrintHostUpload::group, make_url(), port, 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

apikey

std::string Slic3r::Repetier::apikey

private

Referenced by set_auth().

cafile

std::string Slic3r::Repetier::cafile

private

Referenced by set_auth().

host

std::string Slic3r::Repetier::host

private

Referenced by get_host(), and make_url().

port

std::string Slic3r::Repetier::port

private

Referenced by get_groups(), get_printers(), and upload().

---

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

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