void xmlgui::Parameterized::saveToFile(string path) {
ParameterizedGui *p = new ParameterizedGui();
parameterize(p);
p->saveSettings(path);
delete p;
}
/* Function: p7_Builder()
* Synopsis: Build a new HMM from an MSA.
*
* Purpose: Take the multiple sequence alignment <msa> and a build configuration <bld>,
* and build a new HMM.
*
* Effective sequence number determination and calibration steps require
* additionally providing a null model <bg>.
*
* Args: bld - build configuration
* msa - multiple sequence alignment
* bg - null model
* opt_hmm - optRETURN: new HMM
* opt_trarr - optRETURN: array of faux tracebacks, <0..nseq-1>
* opt_gm - optRETURN: profile corresponding to <hmm>
* opt_om - optRETURN: optimized profile corresponding to <gm>
* opt_postmsa - optRETURN: RF-annotated, possibly modified MSA
*
* Returns: <eslOK> on success. The new HMM is optionally returned in
* <*opt_hmm>, along with optional returns of an array of faux tracebacks
* for each sequence in <*opt_trarr>, the annotated MSA used to construct
* the model in <*opt_postmsa>, a configured search profile in
* <*opt_gm>, and an optimized search profile in <*opt_om>. These are
* all optional returns because the caller may, for example, be interested
* only in an optimized profile, or may only be interested in the HMM.
*
* Returns <eslENORESULT> if no consensus columns were annotated.
* Returns <eslEFORMAT> on MSA format problems, such as a missing RF annotation
* line in hand architecture construction. On any returned error,
* <bld->errbuf> contains an informative error message.
*
* Throws: <eslEMEM> on allocation error.
* <eslEINVAL> if relative weights couldn't be calculated from <msa>.
*
* Xref: J4/30.
*/
int
p7_Builder(P7_BUILDER *bld, ESL_MSA *msa, P7_BG *bg,
P7_HMM **opt_hmm, P7_TRACE ***opt_trarr, P7_PROFILE **opt_gm, P7_OPROFILE **opt_om,
ESL_MSA **opt_postmsa)
{
int i,j;
uint32_t checksum = 0; /* checksum calculated for the input MSA. hmmalign --mapali verifies against this. */
P7_HMM *hmm = NULL;
P7_TRACE **tr = NULL;
P7_TRACE ***tr_ptr = (opt_trarr != NULL || opt_postmsa != NULL) ? &tr : NULL;
int status;
if ((status = validate_msa (bld, msa)) != eslOK) goto ERROR;
if ((status = esl_msa_Checksum (msa, &checksum)) != eslOK) ESL_XFAIL(status, bld->errbuf, "Failed to calculate checksum");
if ((status = relative_weights (bld, msa)) != eslOK) goto ERROR;
if ((status = esl_msa_MarkFragments(msa, bld->fragthresh)) != eslOK) goto ERROR;
if ((status = build_model (bld, msa, &hmm, tr_ptr)) != eslOK) goto ERROR;
//Ensures that the weighted-average I->I count <= bld->max_insert_len
//(MI currently contains the number of observed insert-starts)
if (bld->max_insert_len>0)
for (i=1; i<hmm->M; i++ )
hmm->t[i][p7H_II] = ESL_MIN(hmm->t[i][p7H_II], bld->max_insert_len*hmm->t[i][p7H_MI]);
if ((status = effective_seqnumber (bld, msa, hmm, bg)) != eslOK) goto ERROR;
if ((status = parameterize (bld, hmm)) != eslOK) goto ERROR;
if ((status = annotate (bld, msa, hmm)) != eslOK) goto ERROR;
if ((status = calibrate (bld, hmm, bg, opt_gm, opt_om)) != eslOK) goto ERROR;
if ((status = make_post_msa (bld, msa, hmm, tr, opt_postmsa)) != eslOK) goto ERROR;
//force masked positions to background (it'll be close already, so no relevant impact on weighting)
if (hmm->mm != NULL)
for (i=1; i<hmm->M; i++ )
if (hmm->mm[i] == 'm')
for (j=0; j<hmm->abc->K; j++)
hmm->mat[i][j] = bg->f[j];
if ( bld->abc->type == eslDNA || bld->abc->type == eslRNA ) {
if (bld->w_len > 0) hmm->max_length = bld->w_len;
else if (bld->w_beta == 0.0) hmm->max_length = hmm->M *4;
else if ( (status = p7_Builder_MaxLength(hmm, bld->w_beta)) != eslOK) goto ERROR;
}
hmm->checksum = checksum;
hmm->flags |= p7H_CHKSUM;
if (opt_hmm != NULL) *opt_hmm = hmm; else p7_hmm_Destroy(hmm);
if (opt_trarr != NULL) *opt_trarr = tr; else p7_trace_DestroyArray(tr, msa->nseq);
return eslOK;
ERROR:
p7_hmm_Destroy(hmm);
p7_trace_DestroyArray(tr, msa->nseq);
if (opt_gm != NULL) p7_profile_Destroy(*opt_gm);
if (opt_om != NULL) p7_oprofile_Destroy(*opt_om);
return status;
}
void xmlgui::Parameterized::loadFromFile(string path) {
if(path=="") {
path = "settings/"+name+".xml";
}
ParameterizedGui *oldParent = parent;
parent = new ParameterizedGui();
parameterize(parent);
parent->loadSettings(path);
delete parent;
parent = oldParent;
}
// This test verifies that only authorized principals
// can access the '/flags' endpoint.
TYPED_TEST(SlaveAuthorizerTest, AuthorizeFlagsEndpoint)
{
const string endpoint = "flags";
// Setup ACLs so that only the default principal
// can access the '/flags' endpoint.
ACLs acls;
acls.set_permissive(false);
mesos::ACL::GetEndpoint* acl = acls.add_get_endpoints();
acl->mutable_principals()->add_values(DEFAULT_CREDENTIAL.principal());
acl->mutable_paths()->add_values("/" + endpoint);
// Create an `Authorizer` with the ACLs.
Try<Authorizer*> create = TypeParam::create(parameterize(acls));
ASSERT_SOME(create);
Owned<Authorizer> authorizer(create.get());
StandaloneMasterDetector detector;
Try<Owned<cluster::Slave>> agent =
this->StartSlave(&detector, authorizer.get());
ASSERT_SOME(agent);
Future<Response> response = http::get(
agent.get()->pid,
endpoint,
None(),
createBasicAuthHeaders(DEFAULT_CREDENTIAL));
AWAIT_EXPECT_RESPONSE_STATUS_EQ(OK().status, response)
<< response.get().body;
response = http::get(
agent.get()->pid,
endpoint,
None(),
createBasicAuthHeaders(DEFAULT_CREDENTIAL_2));
AWAIT_EXPECT_RESPONSE_STATUS_EQ(Forbidden().status, response)
<< response.get().body;
}
// This test verifies that access to the '/flags' endpoint can be authorized
// without authentication if an authorization rule exists that applies to
// anyone. The authorizer will map the absence of a principal to "ANY".
TYPED_TEST(SlaveAuthorizerTest, AuthorizeFlagsEndpointWithoutPrincipal)
{
const string endpoint = "flags";
// Because the authenticators' lifetime is tied to libprocess's lifetime,
// it may already be set by other tests. We have to unset it here to disable
// HTTP authentication.
// TODO(nfnt): Fix this behavior. The authenticator should be unset by
// every test case that sets it, similar to how it's done for the master.
http::authentication::unsetAuthenticator(
slave::DEFAULT_HTTP_AUTHENTICATION_REALM);
// Setup ACLs so that any principal can access the '/flags' endpoint.
ACLs acls;
acls.set_permissive(false);
mesos::ACL::GetEndpoint* acl = acls.add_get_endpoints();
acl->mutable_principals()->set_type(mesos::ACL::Entity::ANY);
acl->mutable_paths()->add_values("/" + endpoint);
slave::Flags agentFlags = this->CreateSlaveFlags();
agentFlags.acls = acls;
agentFlags.authenticate_http = false;
agentFlags.http_credentials = None();
// Create an `Authorizer` with the ACLs.
Try<Authorizer*> create = TypeParam::create(parameterize(acls));
ASSERT_SOME(create);
Owned<Authorizer> authorizer(create.get());
StandaloneMasterDetector detector;
Try<Owned<cluster::Slave>> agent = this->StartSlave(
&detector, authorizer.get(), agentFlags);
ASSERT_SOME(agent);
Future<Response> response = http::get(agent.get()->pid, endpoint);
AWAIT_EXPECT_RESPONSE_STATUS_EQ(OK().status, response)
<< response.get().body;
}
void execute(char *input) {
// uses fork and exec to create a new process and attempt to execute
// the user command
pid_t pid;
int status;
if ((pid = fork()) < 0) {
fprintf(stderr, "Error forking child process\n");
exit(EXIT_FAILURE);
}
if (pid == 0) {
// child process
char **args = parameterize(input);
if (execvp(args[0], args) == -1) {
fprintf(stderr, "%s: %s\n", args[0], strerror(errno));
exit(EXIT_FAILURE);
}
free(args);
} else {
wait(&status);
}
}
void MainWindow::on_actionMVC_triggered()
{
parameterize(PARAM_MVC);
}
void MainWindow::on_actionDCP_triggered()
{
std::cerr << "DCP...";
parameterize(PARAM_DCP);
}
