Crypto crackdown: Malaysian police steamroll bitcoin machines


Malaysian authorities seized 1,069 bitcoin mining rigs, laid them out in a parking lot at police headquarters, and used a steamroller to crush them, as part of a joint operation between law enforcement in the city of Miri and electric utility Sarawak Energy.

https://www.cnbc.com/2021/07/19/mala…ning-rigs.html

why ansible doesn’t recognize the vcenter windows machines?

I’m pretty new with Ansible so I might configured things wrong
(I have a Docker container running Ansible service in it
I have an Ansible repository that include the Ansible files (this is a .Git repository)

My will was to automatically revert each lab in vCenter server to a specific snapshot
So, I (with the help of ansible-roles-explained-with-examples guide):

  • Created a role with ansible-galaxy init command name vcenter (see directory tree below)
  • Created some vcenter tasks files inside tasks folder (see directory tree below). Here is an example of poweroff.yml task file:
- name: Set the state of a virtual machine to poweroff
  community.vmware.vmware_guest_powerstate:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    folder: "/{{ datacenter_name }}/{{ folder }}"
    # name: "{{ guest_name }}"
    name: "{{ ansible_hostname }}"
    validate_certs: no
    state: powered-off
  delegate_to: localhost
  register: deploy
  • Supplied vCenter credentials in vcentervarsmain.yml file, like this:
# vars file for vcenter
vcenter_hostname: vcenter.foo.com
vcenter_username: hiddai@foo.com
vcenter_password: f#0$o#1$0o
  • Included the tasks in tasksmain.yml file with import-task key, like this:
---
# tasks file for roles/vcenter
- import_tasks: poweroff.yml
# - import_tasks: poweron.yml
# - import_tasks: revert.yml
# - import_tasks: shutdown.yml
  • Created a all.yml inside group_vars folder in inventories library (i don’t know if its a professional way to do like that) that include all winrm details like this:
---
#WinRM Protocol Details
ansible_user: DOMAINuser
ansible_password: f#0$o#1$0o
ansible_connection: winrm
ansible_port: 5985
ansible_winrm_scheme: http
ansible_winrm_server_cert_validation: ignore
ansible_winrm_transport: ntlm
ansible_winrm_read_timeout_sec: 60
ansible_winrm_operation_timeout_sec: 58
  • Created a revert_lab.yml playbook that include the role, like this
---
- name: revert an onpremis lab
  hosts: all
  roles:
  - vcenter

My ansible.cfg is like this:

(defaults)
inventory = /ansible/inventories
roles_path = ./roles:..~/ansible/roles

I executed the playbook to revert all the machines in the lab:

ansible-playbook playbooks/revert_vcenter_lab.yml -i inventories/test/onpremis/domain.com/lab_r.yml

The error I got was:

TASK (Gathering Facts) ****************************************************************************************************************************************************
(WARNING): Error when collecting winrm facts: You cannot call a method on a null-valued expression.  At line:15 char:17  + ...
$ansibleFacts.ansible_win_rm_certificate_expires = $_.Not ...  +                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~      + CategoryInfo          :  
InvalidOperation: (:) (), RuntimeException      + FullyQualifiedErrorId : InvokeMethodOnNull      at <ScriptBlock>, <No file>: line 15  at <ScriptBlock>, <No file>: line  
13
ok: (vm1.domain.com)
ok: (vm2.domain.com)
ok: (vm3.domain.com)
ok: (vm4.domain.com)
ok: (vm5.domain.com)
ok: (vm6.domain.com)
ok: (vm7.domain.com)
ok: (vm8.domain.com)

TASK (vcenter : Set the state of a virtual machine to poweroff) ***********************************************************************************************************
fatal: (vm1.domain.com -> localhost): FAILED! => {"changed": false, "msg": "Unable to set power state for non-existing virtual machine : 'VM1'"}
fatal: (vm2.domain.com -> localhost): FAILED! => {"changed": false, "msg": "Unable to set power state for non-existing virtual machine : 'VM2'"}
fatal: (vm3.domain.com -> localhost): FAILED! => {"changed": false, "msg": "Unable to set power state for non-existing virtual machine : 'VM3'"}
fatal: (vm4.domain.com -> localhost): FAILED! => {"changed": false, "msg": "Unable to set power state for non-existing virtual machine : 'VM4'"}
fatal: (vm5.domain.com -> localhost): FAILED! => {"changed": false, "msg": "Unable to set power state for non-existing virtual machine : 'VM5'"}
fatal: (vm6.domain.com -> localhost): FAILED! => {"changed": false, "msg": "Unable to set power state for non-existing virtual machine : 'VM6'"}
fatal: (vm7.domain.com -> localhost): FAILED! => {"changed": false, "msg": "Unable to set power state for non-existing virtual machine : 'VM7'"}
fatal: (vm8.domain.com -> localhost): FAILED! => {"changed": false, "msg": "Unable to set power state for non-existing virtual machine : 'VM8'"}

PLAY RECAP ****************************************************************************************************************************************************************
vm1.domain.com   : ok=1    changed=0    unreachable=0    failed=1    skipped=0    rescued=0    ignored=0
vm2.domain.com   : ok=1    changed=0    unreachable=0    failed=1    skipped=0    rescued=0    ignored=0
vm3.domain.com   : ok=1    changed=0    unreachable=0    failed=1    skipped=0    rescued=0    ignored=0
vm4.domain.com   : ok=1    changed=0    unreachable=0    failed=1    skipped=0    rescued=0    ignored=0
vm5.domain.com   : ok=1    changed=0    unreachable=0    failed=1    skipped=0    rescued=0    ignored=0
vm6.domain.com   : ok=1    changed=0    unreachable=0    failed=1    skipped=0    rescued=0    ignored=0
vm7.domain.com   : ok=1    changed=0    unreachable=0    failed=1    skipped=0    rescued=0    ignored=0
vm8.domain.com   : ok=1    changed=0    unreachable=0    failed=1    skipped=0    rescued=0    ignored=0

a) How do I get rid of the Error when collecting winrm facts error? (It is look like that the playbook is not recognize the all.yml file with the win, but why?)
b) How do I fix the error “Unable to set power state for non-existing virtual machine…”? (We can see that the playbook access to the machines by fqdns mentioned in the lab_r.yml file (from the inventories library) but the error relates to the machine name as displayed in the vCenter platform…)

My repository:

C:.
├───ansible
│   │   ansible.cfg
│   ├───inventories
│   │   └───test
│   │       ├───cloud
│   │       └───onpremis
│   │           └───domain.com
│   │               │   lab_j.yml
│   │               │   lab_r.yml
│   │               └───group_vars
│   │                       all.yml
│   ├───playbooks
│   │       revert_lab.yml
│   └───roles
│       └───vcenter
│           ├───tasks
│           │       main.yml
│           │       poweroff.yml
│           │       poweron.yml
│           │       revert.yml
│           │       shutdown.yml
│           └───vars
│                   main.yml

turing machines – M does not accept [M] | ‘Correction’ of proof possible?

The language $D={(M)|M((M))=0}$ is not decidable because of the following argument:

Suppose there was a $TM space M_D$ that decides $D$. Then if we gave $M_D space (M) $, there would be two possible outcomes:

1. $M_D((M_D))=1 text{ (accepts)}implies M_D text{ does accept }M_D $, contradiction, because then $M_D((M_D))=0$ must be true.

2. $M_D((M_D))=0 text{ (does not accept})implies M_D text{ does accept }M_D $, contradiction, because then $M_D((M_D))=1 $ must be true.

Anyways, I think most people are familiar with the proof.

My question is:

Where does the following argument fail? (I think this is important to understand other proofs where diagonalization is involved)

Suppose we have a $TM$ $M_D$ that decides if another $TM space M$ does not accept $(M)$. What if we just restrict $M_D$ so that it decides D for almost every other Turing Machine? So in this case we could say: $M_D$ does not decide for itself if $M_D$ accepts $(M_D)$, but it decides for every other Turing Machine.

Is this restriction useless because then it is possible to construct infinitely many Turing Machines for which $M_D$ can not decide whether they accept ‘themselves’?

how can turing machines be universal models of computation if they can’t perform binary search?

Turing Machines can simulate binary search, in the sense that they can compute whatever you can compute using binary search. You seem to be confusing computability and complexity, which are two different things.

Roughly speaking, computability is about what we are able to compute in a given model of computation. We believe Turing machines to be an universal model of computation. All powerful-enough (i.e., Turing complete) models are equivalent to a Turing Machine.

Complexity is about how long it takes to compute something (actually, this is not restricted to time). Different models of computation are not necessarily equivalent complexity-wise.

turing machines – A synctactic property of the complexity class P

In these lecture notes the authors mentions that P is a syntactic complexity class, as we can find a decidable set of encodings for all polynomial time Turing machines. Of course, given a deterministic Turing machine $M$ and a number $k$, we can construct a Turing machine that simulates $M$ for $|x|^k$ steps on input $x$, and, if $M$ halts in these number of steps, returns the same answer as $M$.
Now, every language in P is represented by such a Turing machine, and so, by encoding these Turing machines together with $k$ in a reasonable way, we have a decidable language representing P.

Then, the author defines
$$
L = { langle M, x rangle mid mbox{$M$ is a polynomial-time Turing machine which accepts $x in {0,1}^*$} },
$$

and then claims that $L$ is in P. His argument is that we can first check that we have a valid encoding of $M$ and then run $M$ on input $x$. However, if I assume I have a Turing machine to decide $L$ in time $O(n^k)$ and $M$ is a Turing machine accepting a language in time $n^{k+1}$, then how can the original Turing machine run $M$ on inputs of length that need strictly more time on $M$ than the machine is allowed to run? I somehow think this “diagonalization” argument shows that $L$ could not be in P?

So, what am I missing? I tried to describe as precisely as possible how I understood the claims made, maybe I have understood something wrong…

how can turing machines by universal models of computation if they can’t perform binary search?

Turing Machines can simulate binary search, in the sense that they can compute whatever you can compute using binary search. You seem to be confusing computability and complexity, which are two different things.

Roughly speaking, comparability is about what we are able to compute in a given model of computation. We believe Turing machines to be an universal model of computation. All powerful-enough (i.e., Turing complete) models are equivalent to a Turing Machine.

Complexity is about how long it takes to compute something (actually, this is not restricted to time). Different models of computation are not necessarily equivalent complexity-wise.

mac mini – sharing files from Mac (ubuntu os) to other mac machines

I am trying to set up a file sharing server with an old model mac mini that is running ubuntu 20.04. I am trying to share office documents from the mac mini (server) between other client mac machines.

i am having a frequent issue where the client machines are not able to open new office (word, excel etc) documents between each other.

i keep getting these frequent errors on the mac clients ‘this file is locked for editing’ and ‘This document “x” could not be opened’. Has anyone encountered this error and/or have a solution?

all other files open fine, it is just Microsoft office documents that are giving this issue, im assuming its an office problem but if anyone could supply any info i would be very grateful.

Thank you

(apologies if i haven’t been specific enough i am very tired and have been trying to solve this problem for almost a week now please let me know if any more info is needed)

deployment – Capacity Estimation for Physical Machines Hosting Simplified Nextcloud Instances

I am writing a grant to provide students with free access to Nextcloud VMs, and I need to budget for physical machines. The question is, how can I estimate the number of VMs running just Nextcloud (with just the file sharing applications, basically–no videoconferencing or live editing or similar) that can be supported by a single physical machine? I need this to budget for the number of physical machines to purchase.

I have found some academic papers on this question, but I have no time to implement their models (and they are inadequately validated in real-world circumstances anyway). I have also seen some excessively rough methods of estimation (https://docs.citrix.com/en-us/tech-zone/design/design-decisions/single-server-scalability.html). These don’t help much.

My approach can be rough, but it needs to be evidence-based. For instance, if you have experience with particular hardware supporting several Nextcloud VMs (or something similar to Nextcloud), that would be good. Or if you have thoughts about the factors that are most important to capacity estimation. I have considered load testing tools (Login VSI) as a way to validate my choices after the fact, but I don’t see how I could do it to model things realistically in advance, so any thoughts there would be helpful too.

turing machines – Can there exists mathematical theories not defined via axioms and logic?

Disclaimer

This is a “fuzzy” question so I will try to clarify what I mean. I am not a computer scientist or a mathematician so notations are probably unorthodox and there might be some mistakes in the affirmations below.

Notations

Let $A$ and $N$ be two semi-decidable sets and $n : A to N$ a computable bijection.

The disjoint union $A sqcup N$ can be recursively enumerated, implicitly defining a computable order $<$.

Let $T$ be a semi-decidable $<$-ordered subset of $A sqcup N$.

We can write the following program SearchContradiction:

for t in T:
    let u = n(t) if t in A else n*(t)  // n* denote the inverse of n

    for v in T:
        if u < v:
            break // exit the current loop
        if u = v:
            halt

Note the expression t in A is computable, we can write it as the halting subroutine:

for a in A:
    if t = a:
        return true
    if t < a:
        return false

Definition

We call $(A, N, T, n)$ a theory iff “SearchContradiction does not halt” is a theorem of $ZFC + Con(ZFC)$.

Question

With this definition, $ZFC$, Peano arithmetic, euclidian geometry or constructive analysis are theories. For all these, the program recursively enumerating $T$ is usually defined using a “meta-machine” taking as input a set of axioms and a logic (classical for the first three, intuionistic for the last one).

But is this “meta-machine” Turing-complete or can there exist a theory such that any $T$-enumerator cannot be run on it?