Slic3r::UltiMaker Class Reference

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

Inheritance diagram for Slic3r::UltiMaker:

Collaboration diagram for Slic3r::UltiMaker:

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

Public Member Functions
	UltiMaker (DynamicPrintConfig *config)
	~UltiMaker () 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	has_auth_creds () const
bool	is_authorized () const
std::string	auth_status () const
bool	generate_auth_creds (wxString &msg) const
std::string	test_auth () const
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_api_user () const
const std::string &	get_api_username () const
const std::string &	get_api_password () const
int	getPrintTime (std::string filepath) const
virtual bool	supports_multiple_printers () const
virtual std::string	get_sn () 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 PrintHost *	get_print_host (DynamicPrintConfig *config)
static std::string	get_print_host_webui (DynamicPrintConfig *config)
static int	get_err_code_from_body (const std::string &body)

Protected Member Functions
bool	makeGriffinCompatible (std::string filepath) 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_api_username
std::string	m_api_password
bool	m_ssl_revoke_best_effort

Private Types
enum class	ConnectionType { rrf , dsf , error }

Private Member Functions
std::string	get_upload_url (const std::string &filename, ConnectionType connectionType) const
std::string	get_status_url () const
std::string	get_connect_url () const
std::string	get_base_url () const
std::string	timestamp_str () const
ConnectionType	connect (wxString &msg) const
void	set_auth (Http &http) const
void	disconnect (ConnectionType connectionType) const
bool	start_print (wxString &msg, const std::string &filename, ConnectionType connectionType) const

Private Attributes
std::string	host

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

Member Enumeration Documentation

ConnectionType

enum class Slic3r::UltiMaker::ConnectionType

strongprivate

Enumerator
rrf
dsf
error

{ rrf, dsf, error };

Constructor & Destructor Documentation

UltiMaker()

Slic3r::UltiMaker::UltiMaker ( DynamicPrintConfig * config )

explicit

                                               :
  
  m_host(config->opt_string("print_host")),
  host(config->opt_string("print_host")),
 
    m_api_username(config->opt_string("printhost_user")),
  m_api_password(config->opt_string("printhost_password")),
  m_ssl_revoke_best_effort(config->opt_bool("printhost_ssl_ignore_revoke"))
{}

References host, m_api_password, m_api_username, m_host, and m_ssl_revoke_best_effort.

~UltiMaker()

Slic3r::UltiMaker::~UltiMaker ( )

overridedefault

Member Function Documentation

auth_status()

std::string Slic3r::UltiMaker::auth_status

(

)

const

                                      {
  // returns 'authorized', 'unauthorized', or 'waiting', or 'ERROR: unknown value' on a different output
 
  BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: auth_status() verifying credentials.");
 
    const char* name = get_name();
 
  std::string rtn = "ERROR: unknown value";
    auto url = (boost::format("http://%1%/api/v1/auth/check/%2%") % host % m_api_username).str();
 
    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 verifying credentials: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
 
        })
        .on_complete([&](std::string body, unsigned) {
            BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: url completed without error: %1%") % url;
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got credential verification: %2%") % name % body;
 
            try {
        if (body == "{\"message\": \"unknown\"}") { rtn = "waiting";}
        if (body == "{\"message\": \"authorized\"}"  ) {rtn = "authorized";}
        if (body == "{\"message\": \"unauthorized\"}") {rtn = "unauthorized";}
 
            }
            catch (const std::exception &) {
        BOOST_LOG_TRIVIAL(error) << boost::format("%1%: auth_status Caught error") % name;
            }
        })
#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();
  
  if (boost::starts_with(rtn, "ERROR")) { BOOST_LOG_TRIVIAL(warning) << boost::format("%1%: [auth][auth_status] Unknown value encountered in api/v1/auth/check") % name;}
  return rtn;
}

References error, Slic3r::Http::get(), get_name(), host, Slic3r::http, m_api_username, m_ssl_revoke_best_effort, and set_auth().

Referenced by test_auth().

Here is the call graph for this function:

Here is the caller graph for this function:

can_test()

bool Slic3r::UltiMaker::can_test ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return true; }

connect()

UltiMaker::ConnectionType Slic3r::UltiMaker::connect ( wxString & msg ) const

private

{
  BOOST_LOG_TRIVIAL(info) << boost::format("UltiMaker: Attempting to connect");
  
  auto res = ConnectionType::error;
  auto url = get_connect_url();
 
  auto http = Http::get(std::move(url));
  set_auth(http);
 
  BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: Connecting to url %1%") % url;
 
  http.on_error([&](std::string body, std::string error, unsigned status) {
      auto dsfUrl = get_connect_url();
      auto dsfHttp = Http::get(std::move(dsfUrl));
      dsfHttp.on_error([&](std::string body, std::string error, unsigned status) {
          BOOST_LOG_TRIVIAL(error) << boost::format("UltiMaker: Error connecting: %1%, HTTP %2%, body: `%3%`") % error % status % body;
          msg = format_error(body, error, status);
        })
        .on_complete([&](std::string body, unsigned) {
          res = ConnectionType::dsf;
        })
        .perform_sync();
    })
    .on_complete([&](std::string body, unsigned) {
      BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: Got: %1%") % body;
 
      int err_code = get_err_code_from_body(body);
      switch (err_code) {
        case 0:
          res = ConnectionType::rrf;
          break;
        case 1:
          msg = format_error(body, _u8L("Wrong password"), 0);
          break;
        case 2:
          msg = format_error(body, _u8L("Could not get resources to create a new connection"), 0);
          break;
        default:
          msg = format_error(body, _u8L("Unknown error occurred"), 0);
          break;
      }
 
    })
    .perform_sync();
 
  return res;
}

References _u8L, dsf, error, Slic3r::PrintHost::format_error(), Slic3r::Http::get(), get_connect_url(), Slic3r::PrintHost::get_err_code_from_body(), Slic3r::http, rrf, and set_auth().

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

disconnect()

void Slic3r::UltiMaker::disconnect ( ConnectionType connectionType ) const

private

{
  // we don't need to disconnect from DSF or if it failed anyway
  if (connectionType != ConnectionType::rrf) {
    return;
  }
  auto url =  (boost::format("%1%rr_disconnect")
      % get_base_url()).str();
 
  auto http = Http::get(std::move(url));
  http.on_error([&](std::string body, std::string error, unsigned status) {
    // we don't care about it, if disconnect is not working UltiMaker will disconnect automatically after some time
    BOOST_LOG_TRIVIAL(error) << boost::format("UltiMaker: Error disconnecting: %1%, HTTP %2%, body: `%3%`") % error % status % body;
  })
  .perform_sync();
}

References error, Slic3r::Http::get(), get_base_url(), Slic3r::http, and rrf.

Referenced by upload().

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:

generate_auth_creds()

bool Slic3r::UltiMaker::generate_auth_creds

(

wxString &

msg

)

const

                                                       {
  // Returns true if no error, false otherwise.
 
  BOOST_LOG_TRIVIAL(debug) << "UltiMaker: generate_auth_creds called!";
  bool ret = true;
  /*
    The auth POST request returns json of the form
    {
        "id": "string",
        "key": "string"
    }
    where id is the m_api_username and key is the m_api_password
  */
  const std::string name = get_name();
  std::string application = "OrcaSlicer";
  std::string application_key = "application";
  std::string user = "OrcaSlicer";
  std::string user_key = "user";
  std::string exclusionKey = "OrcaSlicer";
  std::string exclusionKey_key = "OrcaSlicer";
    auto url = (boost::format("http://%1%/api/v1/auth/request") % host).str();
    auto http = Http::post(std::move(url));
 
  // Note: the body/form cannot be blank or OrcaSlicer's Http library crashes on perform_sync()
  http.form_clear();
  http.mime_form_add_text(application_key,application);
  http.mime_form_add_text(user_key,user);
  http.mime_form_add_text(exclusionKey_key,exclusionKey);
 
    http.on_error([name, &msg, &ret](std::string body, std::string error, unsigned status) {
        BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error generating credentials: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
        msg = _L("Error generating credentials! See the log for details.");
    ret = false;
        })
        .on_complete([name, &msg, &ret](std::string body, unsigned) {
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: body: %2%") % name % body;
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: POST request completed without error") % name;
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got credential verification: %2%") % name % body;
 
      std::stringstream sin(body);
      boost::property_tree::ptree pt;
 
        try {
        // Parse JSON into property tree
        boost::property_tree::read_json(sin, pt);
        // Extract the keys from the json
        std::string id  = pt.get<std::string>("id", "");
        std::string key = pt.get<std::string>("key", "");
        BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: Got id and key. ID=%1%") % id;
        BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: KEY=%1%") % key;
 
        if (id.empty() || key.empty()) {
          BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Either ID or KEY is empty.") % name;
          // TRN %1% and %2% are the ID and KEY returned by the printer.
          msg = GUI::format_wxstr(_L("ERROR: Either ID or KEY is empty. ID=%1% KEY=%2%"), id, key);
          ret = false;
        } else {
          BOOST_LOG_TRIVIAL(info) << boost::format("%1%: ID and KEY are both present. Setting message appropriately.") % name;
          // TRN Generated API credentials. %1% is the username, %2% the password.
          msg = GUI::format_wxstr(_L("Username: %1%  Password: %2%"), id, key);
        }
            }
            catch (const std::exception & e) {
        BOOST_LOG_TRIVIAL(error) << boost::format("%1%: generate_auth_creds Caught error") % name;
        BOOST_LOG_TRIVIAL(error) << "Json parse err: " << e.what();
        ret = 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();
 
  
  // Wait for user to authorize on the physical machine
  BOOST_LOG_TRIVIAL(debug) << "UltiMaker: generate_auth_creds done! ret=" << ret;
  return ret;
}

References _L, Slic3r::empty(), error, Slic3r::GUI::format_wxstr(), get_name(), host, Slic3r::http, m_ssl_revoke_best_effort, and Slic3r::Http::post().

Referenced by test().

Here is the call graph for this function:

Here is the caller graph for this function:

get_api_password()

const std::string & Slic3r::UltiMaker::get_api_password ( ) const

inline

{ return m_api_password; }

References m_api_password.

Referenced by set_auth().

Here is the caller graph for this function:

get_api_user()

const std::string & Slic3r::UltiMaker::get_api_user ( ) const

inline

{ return m_api_username; }

References m_api_username.

get_api_username()

const std::string & Slic3r::UltiMaker::get_api_username ( ) const

inline

{ return m_api_username; }

References m_api_username.

Referenced by set_auth().

Here is the caller graph for this function:

get_base_url()

std::string Slic3r::UltiMaker::get_base_url ( ) const

private

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

References host.

Referenced by disconnect(), get_connect_url(), get_status_url(), get_upload_url(), and start_print().

Here is the caller graph for this function:

get_connect_url()

std::string Slic3r::UltiMaker::get_connect_url ( ) const

private

{
  return (boost::format("%1%/printer/status") % get_base_url()).str();
}

References get_base_url().

Referenced by connect().

Here is the call graph for this function:

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::UltiMaker::get_host ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return host; }

References 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::UltiMaker::get_name ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{ return "UltiMaker"; }

Referenced by auth_status(), generate_auth_creds(), is_authorized(), test(), and test_auth().

Here is the caller graph for this function:

get_post_upload_actions()

PrintHostPostUploadActions Slic3r::UltiMaker::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 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::PrintHost::get_print_host_webui ( DynamicPrintConfig * config )

staticinherited

{
    if (config == nullptr)
        return {};
 
    std::string webui_url;
    const auto* host_type_opt = config->option<ConfigOptionEnum<PrintHostType>>("host_type");
    const auto  host_type     = host_type_opt != nullptr ? host_type_opt->value : htOctoPrint;
 
    switch (host_type) {
    case htElegooLink: {
        webui_url = ElegooLink::get_print_host_webui(config);
        break;
    }
    default: break;
    }
 
    if (webui_url.empty()) {
        webui_url = config->opt_string("print_host_webui");
        if (webui_url.empty())
            webui_url = config->opt_string("print_host");
        if (webui_url.empty())
            return webui_url;
    }
 
    const bool has_http_scheme = boost::algorithm::istarts_with(webui_url, "http");
    const bool has_file_scheme = boost::algorithm::istarts_with(webui_url, "file:");
 
    if (!has_http_scheme && !has_file_scheme)
        webui_url = "http://" + webui_url;
 
    return webui_url;
}

References Slic3r::ElegooLink::get_print_host_webui(), Slic3r::htElegooLink, Slic3r::htOctoPrint, Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::GUI::MainFrame::load_printer_url(), Slic3r::GUI::Plater::priv::on_tab_selection_changing(), and Slic3r::GUI::Sidebar::update_all_preset_comboboxes().

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

virtual std::string Slic3r::PrintHost::get_sn ( ) const

inlinevirtualinherited

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 in Slic3r::ElegooLink.

{ return ""; }

get_status_url()

std::string Slic3r::UltiMaker::get_status_url ( ) const

private

{
  return (boost::format("%1%/printer/status") % get_base_url()).str();
}

References get_base_url().

Here is the call graph for this function:

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

overridevirtual

Implements Slic3r::PrintHost.

{
    return GUI::from_u8((boost::format("%s: %s")
                    % _u8L("Could not connect to UltiMaker")
                    % std::string(msg.ToUTF8())).str());
}

References _u8L, and Slic3r::GUI::from_u8().

Here is the call graph for this function:

get_test_ok_msg()

wxString Slic3r::UltiMaker::get_test_ok_msg ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{
  return _L("Connection to UltiMaker works correctly.");
}

References _L.

get_upload_url()

std::string Slic3r::UltiMaker::get_upload_url ( const std::string & filename, ConnectionType connectionType ) const

private

{
    assert(connectionType != ConnectionType::error);
 
  if (connectionType == ConnectionType::dsf) {
    return (boost::format("%1%/machine/file/gcodes/%2%")
        % get_base_url()
        % Http::url_encode(filename)).str();
  } else {
    return get_base_url()+"/print_job";
  }
}

References dsf, error, get_base_url(), and Slic3r::Http::url_encode().

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

getPrintTime()

int Slic3r::UltiMaker::getPrintTime

(

std::string

filepath

)

const

                                                    {
  // Get the total print time in seconds from the provided gcode filepath
  std::ifstream file_in(filepath);
  std::string line;
  int ret = 0;
  bool found = false;
  int h = 0;
  int m = 0;
  int s = 0;
 
  if (file_in.is_open()){
    while (getline(file_in, line) && !found) {
      if (boost::starts_with(line, "; estimated printing time (normal mode) =")) {
        if (sscanf(line.c_str(), "; estimated printing time (normal mode) = %dh %dm %ds", &h, &m, &s) == 3) {
          ret = 3600*h + 60*m + s;
          BOOST_LOG_TRIVIAL(warning) << boost::format("UltiMaker: Hours=%1% Minutes=%2% Seconds=%3% Total Seconds=%4%") % h % m % s % ret;
          found = true;
        } else if (sscanf(line.c_str(), "; estimated printing time (normal mode) = %dm %ds", &m, &s) == 2) {
          ret = 60*m + s;
          BOOST_LOG_TRIVIAL(warning) << boost::format("UltiMaker: No Hours, Minutes=%1% Seconds=%2% Total Seconds=%3%") % m % s % ret;
          found = true;
        } else {
          BOOST_LOG_TRIVIAL(warning) << boost::format("UltiMaker: ERROR: sscanf error while getting total print time, no vars assigned.");
        }
      }
    }
    } else {
    BOOST_LOG_TRIVIAL(error) << boost::format("UltiMaker postprocessing ERROR: file %1% or file %2% was unable to open!") % filepath % (filepath+".temp");
    return 0;
  }
 
  if (!found) {
    BOOST_LOG_TRIVIAL(error) << boost::format("UltiMaker: Print time estimate not found!!");
  }
 
  file_in.close();
 
  return ret;
}

References error.

Referenced by makeGriffinCompatible().

Here is the caller graph for this function:

has_auth_creds()

bool Slic3r::UltiMaker::has_auth_creds

(

)

const

                                    {
  // True if has authentication credentials, false otherwise
  return (!m_api_username.empty()) && (!m_api_password.empty());
}

References m_api_password, and m_api_username.

Referenced by test_auth().

Here is the caller graph for this function:

has_auto_discovery()

bool Slic3r::UltiMaker::has_auto_discovery ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return false; }

is_authorized()

bool Slic3r::UltiMaker::is_authorized

(

)

const

                                   {
 
  BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: is_authorized() checking if creds are valid.");
 
    const char* name = get_name();
 
    bool rtn = false;
    auto url = (boost::format("http://%1%/api/v1/auth/verify") % host).str();
 
    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 verifying credentials: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
 
    if (status == 403 || body == "{\"message\": \"Authorization required.\"}") {
      rtn = false;
    }
 
        })
        .on_complete([&](std::string body, unsigned) {
            BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: url completed without error: %1%") % url;
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got credential verification: %2%") % name % body;
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: [auth] rtn=%2%") % name % rtn; // DEBUG
 
            try {
        // Validate that response is correct
        rtn = (boost::starts_with(body, "\"ok\"") || body == "{\"message\": \"ok\"}");
            }
            catch (const std::exception &) {
                rtn = false;
        BOOST_LOG_TRIVIAL(error) << boost::format("%1%: is_authorized Caught error") % name;
            }
        })
#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();
  
  BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: [auth] rtn=%2%") % name % rtn;
  return rtn;
}

References error, Slic3r::Http::get(), get_name(), host, Slic3r::http, m_ssl_revoke_best_effort, and set_auth().

Referenced by test_auth().

Here is the call graph for this function:

Here is the caller graph for this function:

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.

{}

makeGriffinCompatible()

bool Slic3r::UltiMaker::makeGriffinCompatible ( std::string filepath ) const

protected

                                                              {
  // Modifies the header of the given file path to remove the double colon
  // at the timestamp because >1 colons in a line makes UltiMakers crash.
 
  // Opening and modifying files code was modified from https://www.w3resource.com/cpp-exercises/file-handling/cpp-file-handling-exercise-6.php
  std::string file_temp = filepath+".temp";
  std::ifstream file_in(filepath);
  std::ofstream file_out(file_temp);
  std::string line;
  bool write_on = false;
 
  if (file_in.is_open() && file_out.is_open()){
    while (getline(file_in, line)) {
 
      if (write_on) {
        if (boost::starts_with(line, "; generated by OrcaSlicer")) {
          boost::replace_all(line, ":", "-"); // Replace the colons in the date with dashes to prevent printer crash.
        }
 
        // UM machines need total print time in seconds.
        if (boost::starts_with(line, ";PRINT.TIME:")) {
          file_out << ";PRINT.TIME:"<< getPrintTime(filepath) << "\n";
        
        } else {  
          file_out << line << "\n"; // Write the modified line to the output file
        }
 
      } else if (boost::starts_with(line, ";START_OF_HEADER")) {
        write_on = true;
        file_out << line << "\n";
      }
      }
  } else {
    BOOST_LOG_TRIVIAL(error) << boost::format("UltiMaker: file %1% or file %2% was unable to open!") % filepath % (filepath+".temp");
    return false;
  }
 
  if (!write_on) {
    BOOST_LOG_TRIVIAL(warning) << boost::format("UltiMaker: while postprocessing to make compatible with Griffin, headers not found!");
  }
 
  file_in.close();
  file_out.close();
 
  // Now replace the upload file with the temp one
  std::remove(filepath.c_str());
  std::rename(file_temp.c_str(), filepath.c_str());
  // boost::filesystem::copy_file(file_temp, filepath); // replacement of the above line to keep in /tmp/
  return true;
}

References error, and getPrintTime().

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

set_auth()

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

private

{
    BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: set_auth, m_api_username of %1% and m_api_password of %2%") % get_api_username() % get_api_password();
    http.auth_digest(m_api_username, m_api_password);
}

References get_api_password(), get_api_username(), Slic3r::http, m_api_password, and m_api_username.

Referenced by auth_status(), connect(), is_authorized(), start_print(), test(), and upload().

Here is the call graph for this function:

Here is the caller graph for this function:

start_print()

bool Slic3r::UltiMaker::start_print ( wxString & msg, const std::string & filename, ConnectionType connectionType ) const

private

{
    assert(connectionType != ConnectionType::error);
 
  bool res = false;
  bool dsf = (connectionType == ConnectionType::dsf);
 
  auto url = dsf
    ? (boost::format("%1%machine/code") % get_base_url()).str()
    : (boost::format("%1%rr_gcode?gcode=M32%%20\"0:/gcodes/%2%\"") % get_base_url() % Http::url_encode(filename)).str();
 
  auto http = (dsf ? Http::post(std::move(url)) : Http::get(std::move(url)));
  set_auth(http);
  if (dsf) {
    http.set_post_body(
        (boost::format("M32 \"0:/gcodes/%1%\"") % filename).str()
        );
  }
  http.on_error([&](std::string body, std::string error, unsigned status) {
      BOOST_LOG_TRIVIAL(error) << boost::format("UltiMaker: Error starting print: %1%, HTTP %2%, body: `%3%`") % error % status % body;
      msg = format_error(body, error, status);
    })
    .on_complete([&](std::string body, unsigned) {
      BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: Got: %1%") % body;
      res = true;
    })
    .perform_sync();
 
  return res;
}

References dsf, error, Slic3r::PrintHost::format_error(), Slic3r::Http::get(), get_base_url(), Slic3r::http, Slic3r::Http::post(), set_auth(), and Slic3r::Http::url_encode().

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

overridevirtual

Implements Slic3r::PrintHost.

{
  // Returns true on success, false on error.
  // If called with specific arg, just generate the auth creds.
  if (msg == "generate_auth_creds") {
    BOOST_LOG_TRIVIAL(debug) << "UltiMaker: test called with generate_auth_creds! Generating the auth credentials.";
    return this->generate_auth_creds(msg);
  }
 
  // Since the request is performed synchronously here,
    // it is ok to refer to `msg` from within the closure
  BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: Attempting to test machine");
 
    const char* name = get_name();
 
    bool res = true;
    auto url = (boost::format("http://%1%/api/v1/system/variant") % host).str();
 
    BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Get system variant 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 system variant: %2%, HTTP %3%, body: `%4%`") % name % error % status % body;
        res = false;
        msg = format_error(body, error, status);
        })
        .on_complete([name, &res](std::string body, unsigned) {
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got system variant: %2%") % name % body;
 
      // Validate that response is correct ("UltiMaker 3", "UltiMaker 3 extended" or "UltiMaker S5")
      res = (boost::starts_with(body, "\"Ultimaker 3") || body == "\"Ultimaker S5\"");
        })
#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();
 
 
    BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Testing auth.") % name;
  std::string auth_result = test_auth();
  if ( !boost::starts_with(auth_result,"OK") ) { msg = GUI::from_u8(auth_result); res = false; };
    BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Auth test result: %2%") % name % auth_result;
    return res;
}

References error, Slic3r::PrintHost::format_error(), Slic3r::GUI::from_u8(), generate_auth_creds(), Slic3r::Http::get(), get_name(), host, Slic3r::http, m_ssl_revoke_best_effort, set_auth(), and test_auth().

Here is the call graph for this function:

test_auth()

std::string Slic3r::UltiMaker::test_auth

(

)

const

                                     {
  /* 
  Used in UltiMaker::test(), creates creds if they don't already
  exist, and returns various error strings if errors.
  Returns "OK" if no errors and creds are valid.
  */
  const char* name = get_name();
  BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Testing for presence of auth creds...") % name;
 
  // Auth credentials are alreay existing (user-entered)
  if (has_auth_creds()) {
    BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Has auth credentials. Testing validity...") % name;
 
    std::string auth_stat = auth_status();
    BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: auth_status returned %2%") % name % auth_stat;
 
    if (auth_stat == "waiting") { 
      BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Auth credentials are waiting for user approval at the physical machine.") % name;
      return _u8L("Authentication credentials are waiting for approval. Please approve access via the dialog box on the printer's screen.");
 
    } else if (auth_stat == "authorized" && is_authorized()) {
      BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Auth credentials are valid. Returning OK") % name;
      return "OK";
 
    } else {
      BOOST_LOG_TRIVIAL(warning) << boost::format("%1%: Auth credentials are INVALID. auth_status returned %2%") % name % auth_stat;
      return _u8L("Invalid authentication credentials");
    }
 
  } else { // Auth credentials do not exist
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Auth credentials do NOT already exist. Returning error string.") % name;
    return _u8L("Error: No authentication credentials found!");
  }
 
}

References _u8L, auth_status(), get_name(), has_auth_creds(), and is_authorized().

Referenced by test().

Here is the call graph for this function:

Here is the caller 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:

timestamp_str()

std::string Slic3r::UltiMaker::timestamp_str ( ) const

private

{
  enum { BUFFER_SIZE = 32 };
 
  auto t = std::time(nullptr);
  auto tm = *std::localtime(&t);
 
  char buffer[BUFFER_SIZE];
  std::strftime(buffer, BUFFER_SIZE, "time=%Y-%m-%dT%H:%M:%S", &tm);
 
  return std::string(buffer);
}

upload()

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

overridevirtual

Implements Slic3r::PrintHost.

{
  // Preprocess the file so the machine doesn't crash
  if (makeGriffinCompatible(upload_data.source_path.string())) {
    BOOST_LOG_TRIVIAL(info) << "UltiMaker: [upload] Griffin compatibility appeared successful.";
  } else {
    BOOST_LOG_TRIVIAL(warning) << "UltiMaker: [upload] Griffin compatibility FAILED.";
    return false;
  }
  
  wxString connect_msg;
  auto connectionType = connect(connect_msg);
  if (connectionType == ConnectionType::error) {
    BOOST_LOG_TRIVIAL(warning) << boost::format("UltiMaker: [upload] connectionType is of type error!");
    error_fn(std::move(connect_msg));
    return false;
  }
 
  bool res = true;
  bool dsf = (connectionType == ConnectionType::dsf);
 
  auto upload_cmd = get_upload_url(upload_data.upload_path.string(), connectionType);
  BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: Uploading file %1%, filepath: %2%, post_action: %3%, command: %4%")
    % upload_data.source_path
    % upload_data.upload_path
    % int(upload_data.post_action)
    % upload_cmd;
 
  auto http = (dsf ? Http::put(std::move(upload_cmd)) : Http::post(std::move(upload_cmd)));
  http.form_add("jobname",upload_data.upload_path.string());
  http.form_add_file("file", upload_data.source_path, upload_data.upload_path.string());
 
  set_auth(http);
  http.on_complete([&](std::string body, unsigned status) {
      BOOST_LOG_TRIVIAL(debug) << boost::format("UltiMaker: File uploaded: HTTP %1%: %2%") % status % body;
 
      int err_code = dsf ? (status == 201 ? 0 : 1) : get_err_code_from_body(body);
      if (err_code != 0) {
        BOOST_LOG_TRIVIAL(error) << boost::format("UltiMaker: Request completed but error code was received: %1%") % err_code;
        error_fn(format_error(body, _u8L("Unknown error occurred"), 0));
        res = false;
      } else if (upload_data.post_action == PrintHostPostUploadAction::StartPrint) {
        wxString errormsg;
        res = start_print(errormsg, upload_data.upload_path.string(), connectionType);
        if (! res) {
          error_fn(std::move(errormsg));
        }
      }
    })
    .on_error([&](std::string body, std::string error, unsigned status) {
      BOOST_LOG_TRIVIAL(error) << boost::format("UltiMaker: Error uploading file: %1%, HTTP %2%, body: `%3%`") % 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) << "UltiMaker: Upload canceled";
        res = false;
      }
    })
    .perform_sync();
 
  disconnect(connectionType);
 
  return res;
}

References _u8L, connect(), disconnect(), dsf, error, Slic3r::PrintHost::format_error(), Slic3r::PrintHost::get_err_code_from_body(), get_upload_url(), Slic3r::http, makeGriffinCompatible(), Slic3r::Http::post(), Slic3r::PrintHostUpload::post_action, Slic3r::Http::put(), set_auth(), Slic3r::PrintHostUpload::source_path, start_print(), Slic3r::StartPrint, and Slic3r::PrintHostUpload::upload_path.

Here is the call graph for this function:

Member Data Documentation

host

std::string Slic3r::UltiMaker::host

private

Referenced by UltiMaker(), auth_status(), generate_auth_creds(), get_base_url(), get_host(), is_authorized(), and test().

m_api_password

std::string Slic3r::UltiMaker::m_api_password

protected

Referenced by UltiMaker(), get_api_password(), has_auth_creds(), and set_auth().

m_api_username

std::string Slic3r::UltiMaker::m_api_username

protected

Referenced by UltiMaker(), auth_status(), get_api_user(), get_api_username(), has_auth_creds(), and set_auth().

m_host

std::string Slic3r::UltiMaker::m_host

protected

Referenced by UltiMaker().

m_ssl_revoke_best_effort

bool Slic3r::UltiMaker::m_ssl_revoke_best_effort

protected

Referenced by UltiMaker(), auth_status(), generate_auth_creds(), is_authorized(), and test().

---

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

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